File Coverage

blib/lib/Perlito/Grammar.pm

Criterion	Covered	Total	%
statement	1181	1596	74.0
branch	287	556	51.6
condition	197	559	35.2
subroutine	46	51	90.2
pod	0	41	0.0
total	1711	2803	61.0

line	stmt	bran	cond	sub	pod	time	code
1							# Do not edit this file - Generated by Perlito 7.0
2	31			31		476	use v5;
	31					116
	31					1887
3	31			31		183	use utf8;
	31					67
	31					448
4	31			31		838	use strict;
	31					57
	31					2505
5	31			31		223	use warnings;
	31					184
	31					1447
6	31			31		212	no warnings ('redefine', 'once', 'void', 'uninitialized', 'misc', 'recursion');
	31					60
	31					1910
7	31			31		174	use Perlito::Perl5::Runtime;
	31					72
	31					1340
8	31			31		178	use Perlito::Perl5::Prelude;
	31					69
	31					4780
9							our $MATCH = Perlito::Match->new();
10							{
11							package GLOBAL;
12							sub new { shift; bless { @_ }, "GLOBAL" }
13
14							# use v6
15							;
16							{
17							package Perlito::Grammar;
18							sub new { shift; bless { @_ }, "Perlito::Grammar" }
19	31			31		30561	use Perlito::Expression;
	31					176
	31					1488
20	31			31		38739	use Perlito::Grammar::Regex;
	31					133
	31					1554
21	31			31		25815	use Perlito::Grammar::Control;
	31					108
	31					746541
22							sub is_newline {
23	13163			13163	0	18685	my $grammar = $_[0];
24	13163					17273	my $str = $_[1];
25	13163					16310	my $pos = $_[2];
26	13163					14176	(my $MATCH);
27	13163					53430	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
28	13163					22288	(($MATCH)->{bool} = ((do {
29	13163					37089	((my $pos1) = $MATCH->to());
30							((do {
31	13163	100	66			32106	((((chr(10) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (do {
32	1100					3166	((my $last_pos) = $MATCH->to());
33	1100	50				1558	if (!((do {
34	1100	50				3425	((chr(13) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))
35							}))) {
36	1100					2217	(($MATCH)->{to} = $last_pos)
37							};
38	1100					5509	1
39							}))
40	13163	100				17525	}) \|\| (do {
41	12063					20184	(($MATCH)->{to} = $pos1);
42	12063	50	33			32672	(((((chr(13) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (do {
43	0					0	((my $last_pos) = $MATCH->to());
44	0	0				0	if (!((do {
45	0	0				0	((chr(10) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))
46							}))) {
47	0					0	(($MATCH)->{to} = $last_pos)
48							};
49	0					0	1
50							})))
51							}))
52							})));
53	13163					34790	$MATCH
54							};
55							sub not_newline {
56	335			335	0	448	my $grammar = $_[0];
57	335					383	my $str = $_[1];
58	335					378	my $pos = $_[2];
59	335					409	(my $MATCH);
60	335					1196	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
61	335					448	(($MATCH)->{bool} = ((do {
62	335					838	((my $pos1) = $MATCH->to());
63	335					656	(do {
64	335	100	33			378	((do {
65	335					410	((my $tmp) = $MATCH);
66	335					1077	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $tmp->to()), ('to' => $tmp->to()), ('bool' => 1)));
67	335					468	(($MATCH)->{bool} = (do {
68	335					808	((my $pos1) = $MATCH->to());
69	335					388	(do {
70	335					982	((my $m2) = $grammar->is_newline($str, $MATCH->to()));
71	335	100				997	if ($m2) {
72	12					45	(($MATCH)->{to} = $m2->to());
73	12					43	1
74							}
75							else {
76	323					1034	0
77							}
78							})
79							}));
80	335					1160	(($tmp)->{bool} = !($MATCH));
81	335					449	($MATCH = $tmp);
82	335					1340	!!($MATCH)
83							}) && ((('' ne substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
84							})
85							})));
86	335					876	$MATCH
87							};
88							sub ident {
89	9696			9696	0	15641	my $grammar = $_[0];
90	9696					12494	my $str = $_[1];
91	9696					20543	my $pos = $_[2];
92	9696					9863	(my $MATCH);
93	9696					43394	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
94	9696					13320	(($MATCH)->{bool} = ((do {
95	9696					27141	((my $pos1) = $MATCH->to());
96	9696					12177	(do {
97							((do {
98	9696					12396	((my $tmp) = $MATCH);
99	9696					34406	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $tmp->to()), ('to' => $tmp->to()), ('bool' => 1)));
100	9696					13557	(($MATCH)->{bool} = (do {
101	9696					26162	((my $pos1) = $MATCH->to());
102	9696					23182	(do {
103	9696					31104	((my $m2) = $grammar->digit($str, $MATCH->to()));
104	9696	100				39291	if ($m2) {
105	981					2685	(($MATCH)->{to} = $m2->to());
106	981					3228	1
107							}
108							else {
109	8715					32682	0
110							}
111							})
112							}));
113	9696					27796	(($tmp)->{bool} = !($MATCH));
114	9696					15713	($MATCH = $tmp);
115	9696					31967	!!($MATCH)
116	9696	100				12772	}) && (do {
117	8715					12876	((my $last_match_null) = 0);
118	8715					25639	((my $last_pos) = $MATCH->to());
119	8715					12463	((my $count) = 0);
120	8715		66			11389	for ( ; ((do {
121	16827					43969	((my $m2) = $grammar->word($str, $MATCH->to()));
122	16827	100				44772	if ($m2) {
123	8112					23669	(($MATCH)->{to} = $m2->to());
124	8112					47818	1
125							}
126							else {
127	8715					41055	0
128							}
129							}) && (($last_match_null < 2))); ) {
130	8112	50				25304	if (($last_pos == $MATCH->to())) {
131	0					0	($last_match_null = ($last_match_null + 1))
132							}
133							else {
134	8112					11077	($last_match_null = 0)
135							};
136	8112					20236	($last_pos = $MATCH->to());
137	8112					11982	($count = ($count + 1))
138							};
139	8715					15449	(($MATCH)->{to} = $last_pos);
140	8715					28098	($count > 0)
141							}))
142							})
143							})));
144	9696					29391	$MATCH
145							};
146							sub full_ident {
147	685			685	0	3780	my $grammar = $_[0];
148	685					1203	my $str = $_[1];
149	685					1027	my $pos = $_[2];
150	685					913	(my $MATCH);
151	685					2989	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
152	685					1110	(($MATCH)->{bool} = ((do {
153	685					2151	((my $pos1) = $MATCH->to());
154	685					1091	(do {
155							((do {
156	685					2129	((my $m2) = $grammar->ident($str, $MATCH->to()));
157	685	100				2171	if ($m2) {
158	578					1946	(($MATCH)->{to} = $m2->to());
159	578					3248	1
160							}
161							else {
162	107					649	0
163							}
164	685	100				1685	}) && (do {
165	578					1352	((my $last_match_null) = 0);
166	578					1825	((my $last_pos) = $MATCH->to());
167	578		66			1140	for ( ; ((do {
168	579					1785	((my $pos1) = $MATCH->to());
169	579					1175	(do {
170	579	100	66			1870	(((('::' eq substr($str, $MATCH->to(), 2)) && ((($MATCH)->{to} = (2 + $MATCH->to()))))) && (do {
171	1					10	((my $m2) = $grammar->ident($str, $MATCH->to()));
172	1	50				3	if ($m2) {
173	1					3	(($MATCH)->{to} = $m2->to());
174	1					8	1
175							}
176							else {
177	0					0	0
178							}
179							}))
180							})
181							}) && (($last_match_null < 2))); ) {
182	1	50				4	if (($last_pos == $MATCH->to())) {
183	0					0	($last_match_null = ($last_match_null + 1))
184							}
185							else {
186	1					2	($last_match_null = 0)
187							};
188	1					4	($last_pos = $MATCH->to())
189							};
190	578					1448	(($MATCH)->{to} = $last_pos);
191	578					1529	1
192							}))
193							})
194							})));
195	685					1951	$MATCH
196							};
197							sub namespace_before_ident {
198	3240			3240	0	4973	my $grammar = $_[0];
199	3240					4661	my $str = $_[1];
200	3240					5211	my $pos = $_[2];
201	3240					4086	(my $MATCH);
202	3240					11708	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
203	3240					17125	(($MATCH)->{bool} = ((do {
204	3240					14237	((my $pos1) = $MATCH->to());
205	3240					4586	(do {
206							(((do {
207	3240					9065	((my $m2) = $grammar->ident($str, $MATCH->to()));
208	3240	100				9502	if ($m2) {
209	879					2795	(($MATCH)->{to} = $m2->to());
210	879					4382	1
211							}
212							else {
213	2361					14542	0
214							}
215							}) && (do {
216	879					1548	((my $tmp) = $MATCH);
217	879					3644	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $tmp->to()), ('to' => $tmp->to()), ('bool' => 1)));
218	879					1626	(($MATCH)->{bool} = (do {
219	879					2800	((my $pos1) = $MATCH->to());
220	879					1401	(do {
221	879	100				2879	(('::' eq substr($str, $MATCH->to(), 2)) && ((($MATCH)->{to} = (2 + $MATCH->to()))))
222							})
223							}));
224	879					2887	(($tmp)->{bool} = !!($MATCH));
225	879					1929	($MATCH = $tmp);
226	879					3051	!!($MATCH)
227	3240	100	66			4030	})) && (do {
228	14					35	((my $last_match_null) = 0);
229	14					49	((my $last_pos) = $MATCH->to());
230	14		66			29	for ( ; ((do {
231	16					60	((my $pos1) = $MATCH->to());
232	16					30	(do {
233							((((('::' eq substr($str, $MATCH->to(), 2)) && ((($MATCH)->{to} = (2 + $MATCH->to()))))) && (do {
234	16					60	((my $m2) = $grammar->ident($str, $MATCH->to()));
235	16	50				50	if ($m2) {
236	16					58	(($MATCH)->{to} = $m2->to());
237	16					108	1
238							}
239							else {
240	0					0	0
241							}
242	16	50	33			59	})) && (do {
			33
243	16					31	((my $tmp) = $MATCH);
244	16					65	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $tmp->to()), ('to' => $tmp->to()), ('bool' => 1)));
245	16					30	(($MATCH)->{bool} = (do {
246	16					61	((my $pos1) = $MATCH->to());
247	16					50	(do {
248	16	100				64	(('::' eq substr($str, $MATCH->to(), 2)) && ((($MATCH)->{to} = (2 + $MATCH->to()))))
249							})
250							}));
251	16					88	(($tmp)->{bool} = !!($MATCH));
252	16					41	($MATCH = $tmp);
253	16					56	!!($MATCH)
254							}))
255							})
256							}) && (($last_match_null < 2))); ) {
257	2	50				8	if (($last_pos == $MATCH->to())) {
258	0					0	($last_match_null = ($last_match_null + 1))
259							}
260							else {
261	2					3	($last_match_null = 0)
262							};
263	2					13	($last_pos = $MATCH->to())
264							};
265	14					46	(($MATCH)->{to} = $last_pos);
266	14					41	1
267							}))
268							})
269							})));
270	3240					9081	$MATCH
271							};
272							sub optional_namespace_before_ident {
273	3240			3240	0	6245	my $grammar = $_[0];
274	3240					5012	my $str = $_[1];
275	3240					4112	my $pos = $_[2];
276	3240					3911	(my $MATCH);
277	3240					12321	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
278	3240					6185	(($MATCH)->{bool} = ((do {
279	3240					9821	((my $pos1) = $MATCH->to());
280							((do {
281							(((do {
282	3240					9083	((my $m2) = $grammar->namespace_before_ident($str, $MATCH->to()));
283	3240	100				9340	if ($m2) {
284	14					79	(($MATCH)->{to} = $m2->to());
285	14					40	($MATCH->{'namespace_before_ident'} = $m2);
286	14					125	1
287							}
288							else {
289	3226					25784	0
290							}
291	3240	50	50			3811	}) && ((('::' eq substr($str, $MATCH->to(), 2)) && ((($MATCH)->{to} = (2 + $MATCH->to())))))) && (((do {
			33
			66
292	14					63	($MATCH->{capture} = ("".($MATCH->{'namespace_before_ident'})))
293							}) \|\| 1)))
294	3240	100				4458	}) \|\| (do {
295	3226					5940	(($MATCH)->{to} = $pos1);
296	3226	50				4346	((1 && (((do {
297	3226					18921	($MATCH->{capture} = (''))
298							}) \|\| 1))))
299							}))
300							})));
301	3240					10827	$MATCH
302							};
303							sub pod_begin {
304	0			0	0	0	my $grammar = $_[0];
305	0					0	my $str = $_[1];
306	0					0	my $pos = $_[2];
307	0					0	(my $MATCH);
308	0					0	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
309	0					0	(($MATCH)->{bool} = ((do {
310	0					0	((my $pos1) = $MATCH->to());
311							((do {
312							(((do {
313	0					0	((my $m2) = $grammar->is_newline($str, $MATCH->to()));
314	0	0				0	if ($m2) {
315	0					0	(($MATCH)->{to} = $m2->to());
316	0					0	1
317							}
318							else {
319	0					0	0
320							}
321	0	0	0			0	}) && (((chr(61) . 'end' eq substr($str, $MATCH->to(), 4)) && ((($MATCH)->{to} = (4 + $MATCH->to())))))) && (do {
			0
322	0					0	((my $last_match_null) = 0);
323	0					0	((my $last_pos) = $MATCH->to());
324	0		0			0	for ( ; ((do {
325	0					0	((my $m2) = $grammar->not_newline($str, $MATCH->to()));
326	0	0				0	if ($m2) {
327	0					0	(($MATCH)->{to} = $m2->to());
328	0					0	1
329							}
330							else {
331	0					0	0
332							}
333							}) && (($last_match_null < 2))); ) {
334	0	0				0	if (($last_pos == $MATCH->to())) {
335	0					0	($last_match_null = ($last_match_null + 1))
336							}
337							else {
338	0					0	($last_match_null = 0)
339							};
340	0					0	($last_pos = $MATCH->to())
341							};
342	0					0	(($MATCH)->{to} = $last_pos);
343	0					0	1
344							}))
345	0	0				0	}) \|\| (do {
346	0					0	(($MATCH)->{to} = $pos1);
347							(((((('' ne substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (do {
348	0					0	((my $last_match_null) = 0);
349	0					0	((my $last_pos) = $MATCH->to());
350	0		0			0	for ( ; ((do {
351	0					0	((my $m2) = $grammar->not_newline($str, $MATCH->to()));
352	0	0				0	if ($m2) {
353	0					0	(($MATCH)->{to} = $m2->to());
354	0					0	1
355							}
356							else {
357	0					0	0
358							}
359							}) && (($last_match_null < 2))); ) {
360	0	0				0	if (($last_pos == $MATCH->to())) {
361	0					0	($last_match_null = ($last_match_null + 1))
362							}
363							else {
364	0					0	($last_match_null = 0)
365							};
366	0					0	($last_pos = $MATCH->to())
367							};
368	0					0	(($MATCH)->{to} = $last_pos);
369	0					0	1
370	0	0	0			0	})) && (do {
			0
371	0					0	((my $m2) = $grammar->pod_begin($str, $MATCH->to()));
372	0	0				0	if ($m2) {
373	0					0	(($MATCH)->{to} = $m2->to());
374	0					0	1
375							}
376							else {
377	0					0	0
378							}
379							})))
380							}))
381							})));
382	0					0	$MATCH
383							};
384							sub ws {
385	5314			5314	0	11517	my $grammar = $_[0];
386	5314					8323	my $str = $_[1];
387	5314					9237	my $pos = $_[2];
388	5314					6080	(my $MATCH);
389	5314					19279	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
390	5314					9681	(($MATCH)->{bool} = ((do {
391	5314					21405	((my $pos1) = $MATCH->to());
392	5314					7433	(do {
393	5314					7221	((my $last_match_null) = 0);
394	5314					15098	((my $last_pos) = $MATCH->to());
395	5314					9005	((my $count) = 0);
396	5314		66			12569	for ( ; ((do {
397	12584					31340	((my $pos1) = $MATCH->to());
398							(((do {
399	12584	100	66			34442	((((chr(35) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (do {
400	12					23	((my $last_match_null) = 0);
401	12					43	((my $last_pos) = $MATCH->to());
402	12		66			23	for ( ; ((do {
403	335					937	((my $m2) = $grammar->not_newline($str, $MATCH->to()));
404	335	100				872	if ($m2) {
405	323					820	(($MATCH)->{to} = $m2->to());
406	323					1829	1
407							}
408							else {
409	12					59	0
410							}
411							}) && (($last_match_null < 2))); ) {
412	323	50				868	if (($last_pos == $MATCH->to())) {
413	0					0	($last_match_null = ($last_match_null + 1))
414							}
415							else {
416	323					432	($last_match_null = 0)
417							};
418	323					791	($last_pos = $MATCH->to())
419							};
420	12					35	(($MATCH)->{to} = $last_pos);
421	12					95	1
422							}))
423							}) \|\| (do {
424	12572					23593	(($MATCH)->{to} = $pos1);
425							(((do {
426	12572					42065	((my $m2) = $grammar->is_newline($str, $MATCH->to()));
427	12572	100				49165	if ($m2) {
428	973					3310	(($MATCH)->{to} = $m2->to());
429	973					4683	1
430							}
431							else {
432	11599					76898	0
433							}
434	12572	100				18234	}) && (do {
435	973					3085	((my $pos1) = $MATCH->to());
436							(((do {
437	973	50	33			2986	((((chr(61) . 'begin' eq substr($str, $MATCH->to(), 6)) && ((($MATCH)->{to} = (6 + $MATCH->to()))))) && (do {
438	0					0	((my $m2) = $grammar->pod_begin($str, $MATCH->to()));
439	0	0				0	if ($m2) {
440	0					0	(($MATCH)->{to} = $m2->to());
441	0					0	1
442							}
443							else {
444	0					0	0
445							}
446							}))
447							}) \|\| (do {
448	973					1901	(($MATCH)->{to} = $pos1);
449	973	50	33			2938	(((((chr(61) . 'for' eq substr($str, $MATCH->to(), 4)) && ((($MATCH)->{to} = (4 + $MATCH->to()))))) && (do {
450	0					0	((my $m2) = $grammar->pod_begin($str, $MATCH->to()));
451	0	0				0	if ($m2) {
452	0					0	(($MATCH)->{to} = $m2->to());
453	0					0	1
454							}
455							else {
456	0					0	0
457							}
458							})))
459	973	50	33			1454	})) \|\| (do {
460	973					2013	(($MATCH)->{to} = $pos1);
461	973					6069	(1)
462							}))
463							})))
464	12584	100	66			17672	})) \|\| (do {
465	11599					20875	(($MATCH)->{to} = $pos1);
466	11599					12790	((do {
467	11599					43379	((my $m2) = $grammar->space($str, $MATCH->to()));
468	11599	100				32127	if ($m2) {
469	6285					19070	(($MATCH)->{to} = $m2->to());
470	6285					58549	1
471							}
472							else {
473	5314					31001	0
474							}
475							}))
476							}))
477							}) && (($last_match_null < 2))); ) {
478	7270	50				28511	if (($last_pos == $MATCH->to())) {
479	0					0	($last_match_null = ($last_match_null + 1))
480							}
481							else {
482	7270					11696	($last_match_null = 0)
483							};
484	7270					18849	($last_pos = $MATCH->to());
485	7270					11369	($count = ($count + 1))
486							};
487	5314					12358	(($MATCH)->{to} = $last_pos);
488	5314					15296	($count > 0)
489							})
490							})));
491	5314					16412	$MATCH
492							};
493							sub opt_ws {
494	451			451	0	1093	my $grammar = $_[0];
495	451					708	my $str = $_[1];
496	451					632	my $pos = $_[2];
497	451					550	(my $MATCH);
498	451					2186	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
499	451					1001	(($MATCH)->{bool} = ((do {
500	451					1330	((my $pos1) = $MATCH->to());
501	451					640	(do {
502	451					1387	((my $last_pos) = $MATCH->to());
503	451	100				668	if (!((do {
504	451					1315	((my $m2) = $grammar->ws($str, $MATCH->to()));
505	451	100				1318	if ($m2) {
506	182					607	(($MATCH)->{to} = $m2->to());
507	182					703	1
508							}
509							else {
510	269					1232	0
511							}
512							}))) {
513	269					552	(($MATCH)->{to} = $last_pos)
514							};
515	451					1165	1
516							})
517							})));
518	451					1268	$MATCH
519							};
520							sub opt_ws2 {
521	15			15	0	24	my $grammar = $_[0];
522	15					20	my $str = $_[1];
523	15					24	my $pos = $_[2];
524	15					20	(my $MATCH);
525	15					56	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
526	15					23	(($MATCH)->{bool} = ((do {
527	15					47	((my $pos1) = $MATCH->to());
528	15					20	(do {
529	15					49	((my $last_pos) = $MATCH->to());
530	15	100				21	if (!((do {
531	15					44	((my $m2) = $grammar->ws($str, $MATCH->to()));
532	15	100				43	if ($m2) {
533	11					37	(($MATCH)->{to} = $m2->to());
534	11					44	1
535							}
536							else {
537	4					19	0
538							}
539							}))) {
540	4					1548	(($MATCH)->{to} = $last_pos)
541							};
542	15					40	1
543							})
544							})));
545	15					45	$MATCH
546							};
547							sub opt_ws3 {
548	4			4	0	11	my $grammar = $_[0];
549	4					8	my $str = $_[1];
550	4					13	my $pos = $_[2];
551	4					7	(my $MATCH);
552	4					21	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
553	4					11	(($MATCH)->{bool} = ((do {
554	4					14	((my $pos1) = $MATCH->to());
555	4					9	(do {
556	4					14	((my $last_pos) = $MATCH->to());
557	4	50				8	if (!((do {
558	4					28	((my $m2) = $grammar->ws($str, $MATCH->to()));
559	4	50				14	if ($m2) {
560	4					28	(($MATCH)->{to} = $m2->to());
561	4					23	1
562							}
563							else {
564	0					0	0
565							}
566							}))) {
567	0					0	(($MATCH)->{to} = $last_pos)
568							};
569	4					13	1
570							})
571							})));
572	4					13	$MATCH
573							};
574							sub grammar {
575	36			36	0	125	my $grammar = $_[0];
576	36					80	my $str = $_[1];
577	36					125	my $pos = $_[2];
578	36					78	(my $MATCH);
579	36					178	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
580	36					69	(($MATCH)->{bool} = ((do {
581	36					134	((my $pos1) = $MATCH->to());
582	36					66	(do {
583							((((((((do {
584	36					142	((my $m2) = $grammar->full_ident($str, $MATCH->to()));
585	36	50				126	if ($m2) {
586	36					158	(($MATCH)->{to} = $m2->to());
587	36					100	($MATCH->{'full_ident'} = $m2);
588	36					182	1
589							}
590							else {
591	0					0	0
592							}
593							}) && (do {
594	36					152	((my $last_pos) = $MATCH->to());
595	36	50				84	if (!((do {
596	36					152	((my $m2) = $grammar->ws($str, $MATCH->to()));
597	36	50				123	if ($m2) {
598	36					161	(($MATCH)->{to} = $m2->to());
599	36					216	1
600							}
601							else {
602	0					0	0
603							}
604							}))) {
605	0					0	(($MATCH)->{to} = $last_pos)
606							};
607	36					347	1
608							})) && (((chr(123) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to())))))) && (do {
609	36					183	((my $last_pos) = $MATCH->to());
610	36	50				107	if (!((do {
611	36					235	((my $m2) = $grammar->ws($str, $MATCH->to()));
612	36	50				127	if ($m2) {
613	36					161	(($MATCH)->{to} = $m2->to());
614	36					343	1
615							}
616							else {
617	0					0	0
618							}
619							}))) {
620	0					0	(($MATCH)->{to} = $last_pos)
621							};
622	36					215	1
623							})) && (do {
624	36					168	((my $m2) = $grammar->exp_stmts($str, $MATCH->to()));
625	36	50				150	if ($m2) {
626	36					1555	(($MATCH)->{to} = $m2->to());
627	36					363	($MATCH->{'exp_stmts'} = $m2);
628	36					242	1
629							}
630							else {
631	0					0	0
632							}
633							})) && (do {
634	36					165	((my $last_pos) = $MATCH->to());
635	36	50				80	if (!((do {
636	36					168	((my $m2) = $grammar->ws($str, $MATCH->to()));
637	36	50				134	if ($m2) {
638	0					0	(($MATCH)->{to} = $m2->to());
639	0					0	1
640							}
641							else {
642	36					212	0
643							}
644							}))) {
645	36					93	(($MATCH)->{to} = $last_pos)
646							};
647	36					335	1
648	36	50	50			83	})) && (((chr(125) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to())))))) && (((do {
			33
			33
			33
			33
			33
			33
			33
			33
649	36					84	($MATCH->{capture} = (CompUnit->new(('name' => ${$MATCH->{'full_ident'}}), ('body' => ${$MATCH->{'exp_stmts'}}))))
	36					153
	36					148
650							}) \|\| 1)))
651							})
652							})));
653	36					348	$MATCH
654							};
655							sub declarator {
656	2866			2866	0	5888	my $grammar = $_[0];
657	2866					4247	my $str = $_[1];
658	2866					3535	my $pos = $_[2];
659	2866					9729	(my $MATCH);
660	2866					12746	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
661	2866					4570	(($MATCH)->{bool} = ((do {
662	2866					8504	((my $pos1) = $MATCH->to());
663							(((do {
664	2866	100				7716	(('my' eq substr($str, $MATCH->to(), 2)) && ((($MATCH)->{to} = (2 + $MATCH->to()))))
665							}) \|\| (do {
666	2785					5355	(($MATCH)->{to} = $pos1);
667	2785	50				7992	(((('state' eq substr($str, $MATCH->to(), 5)) && ((($MATCH)->{to} = (5 + $MATCH->to()))))))
668	2866	50	66			3907	})) \|\| (do {
669	2785					4894	(($MATCH)->{to} = $pos1);
670	2785	100				12680	(((('has' eq substr($str, $MATCH->to(), 3)) && ((($MATCH)->{to} = (3 + $MATCH->to()))))))
671							}))
672							})));
673	2866					12180	$MATCH
674							};
675							sub exp_stmts2 {
676	0			0	0	0	my $grammar = $_[0];
677	0					0	my $str = $_[1];
678	0					0	my $pos = $_[2];
679	0					0	(my $MATCH);
680	0					0	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
681	0					0	(($MATCH)->{bool} = ((do {
682	0					0	((my $pos1) = $MATCH->to());
683	0					0	(do {
684							((do {
685	0					0	((my $m2) = $grammar->exp_stmts($str, $MATCH->to()));
686	0	0				0	if ($m2) {
687	0					0	(($MATCH)->{to} = $m2->to());
688	0					0	($MATCH->{'exp_stmts'} = $m2);
689	0					0	1
690							}
691							else {
692	0					0	0
693							}
694	0	0	0			0	}) && (((do {
695	0					0	($MATCH->{capture} = (${$MATCH->{'exp_stmts'}}))
	0					0
696							}) \|\| 1)))
697							})
698							})));
699	0					0	$MATCH
700							};
701							sub exp {
702	90			90	0	220	my $grammar = $_[0];
703	90					183	my $str = $_[1];
704	90					169	my $pos = $_[2];
705	90					138	(my $MATCH);
706	90					593	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
707	90					208	(($MATCH)->{bool} = ((do {
708	90					415	((my $pos1) = $MATCH->to());
709	90					183	(do {
710							((do {
711	90					334	((my $m2) = Perlito::Expression->exp_parse($str, $MATCH->to()));
712	90	50				921	if ($m2) {
713	90					351	(($MATCH)->{to} = $m2->to());
714	90					456	($MATCH->{'Perlito::Expression.exp_parse'} = $m2);
715	90					677	1
716							}
717							else {
718	0					0	0
719							}
720	90	50	50			138	}) && (((do {
721	90					145	($MATCH->{capture} = (${$MATCH->{'Perlito::Expression.exp_parse'}}))
	90					345
722							}) \|\| 1)))
723							})
724							})));
725	90					460	$MATCH
726							};
727							sub exp2 {
728	14			14	0	36	my $grammar = $_[0];
729	14					35	my $str = $_[1];
730	14					28	my $pos = $_[2];
731	14					23	(my $MATCH);
732	14					74	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
733	14					30	(($MATCH)->{bool} = ((do {
734	14					53	((my $pos1) = $MATCH->to());
735	14					25	(do {
736							((do {
737	14					50	((my $m2) = Perlito::Expression->exp_parse($str, $MATCH->to()));
738	14	50				61	if ($m2) {
739	14					57	(($MATCH)->{to} = $m2->to());
740	14					44	($MATCH->{'Perlito::Expression.exp_parse'} = $m2);
741	14					71	1
742							}
743							else {
744	0					0	0
745							}
746	14	50	50			28	}) && (((do {
747	14					24	($MATCH->{capture} = (${$MATCH->{'Perlito::Expression.exp_parse'}}))
	14					47
748							}) \|\| 1)))
749							})
750							})));
751	14					72	$MATCH
752							};
753							sub opt_ident {
754	0			0	0	0	my $grammar = $_[0];
755	0					0	my $str = $_[1];
756	0					0	my $pos = $_[2];
757	0					0	(my $MATCH);
758	0					0	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
759	0					0	(($MATCH)->{bool} = ((do {
760	0					0	((my $pos1) = $MATCH->to());
761							((do {
762							((do {
763	0					0	((my $m2) = $grammar->ident($str, $MATCH->to()));
764	0	0				0	if ($m2) {
765	0					0	(($MATCH)->{to} = $m2->to());
766	0					0	($MATCH->{'ident'} = $m2);
767	0					0	1
768							}
769							else {
770	0					0	0
771							}
772	0	0	0			0	}) && (((do {
773	0					0	($MATCH->{capture} = (${$MATCH->{'ident'}}))
	0					0
774							}) \|\| 1)))
775	0	0				0	}) \|\| (do {
776	0					0	(($MATCH)->{to} = $pos1);
777	0	0				0	((1 && (((do {
778	0					0	($MATCH->{capture} = ('postcircumfix:<( )>'))
779							}) \|\| 1))))
780							}))
781							})));
782	0					0	$MATCH
783							};
784							sub opt_type {
785	83			83	0	213	my $grammar = $_[0];
786	83					204	my $str = $_[1];
787	83					305	my $pos = $_[2];
788	83					141	(my $MATCH);
789	83					466	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
790	83					179	(($MATCH)->{bool} = ((do {
791	83					313	((my $pos1) = $MATCH->to());
792							((do {
793							(((do {
794	83					1228	((my $last_pos) = $MATCH->to());
795	83	50				150	if (!((do {
796	83	50				291	(('::' eq substr($str, $MATCH->to(), 2)) && ((($MATCH)->{to} = (2 + $MATCH->to()))))
797							}))) {
798	83					233	(($MATCH)->{to} = $last_pos)
799							};
800	83					398	1
801							}) && (do {
802	83					313	((my $m2) = $grammar->full_ident($str, $MATCH->to()));
803	83	50				251	if ($m2) {
804	0					0	(($MATCH)->{to} = $m2->to());
805	0					0	($MATCH->{'full_ident'} = $m2);
806	0					0	1
807							}
808							else {
809	83					966	0
810							}
811	83	50	0			139	})) && (((do {
			33
812	0					0	($MATCH->{capture} = (${$MATCH->{'full_ident'}}))
	0					0
813							}) \|\| 1)))
814	83	50				140	}) \|\| (do {
815	83					188	(($MATCH)->{to} = $pos1);
816	83	50				141	((1 && (((do {
817	83					577	($MATCH->{capture} = (''))
818							}) \|\| 1))))
819							}))
820							})));
821	83					528	$MATCH
822							};
823							sub var_sigil {
824	5628			5628	0	8189	my $grammar = $_[0];
825	5628					7607	my $str = $_[1];
826	5628					6709	my $pos = $_[2];
827	5628					6189	(my $MATCH);
828	5628					21976	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
829	5628					8218	(($MATCH)->{bool} = ((do {
830	5628					14863	((my $pos1) = $MATCH->to());
831							((((do {
832	5628	100				14855	((chr(36) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))
833							}) \|\| (do {
834	5152					15499	(($MATCH)->{to} = $pos1);
835	5152	100				13807	((((chr(37) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
836							})) \|\| (do {
837	5129					9099	(($MATCH)->{to} = $pos1);
838	5129	100				13433	((((chr(64) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
839	5628	100	66			7175	})) \|\| (do {
			66
840	5079					8288	(($MATCH)->{to} = $pos1);
841	5079	100				14839	((((chr(38) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
842							}))
843							})));
844	5628					16903	$MATCH
845							};
846							sub var_twigil {
847	567			567	0	1066	my $grammar = $_[0];
848	567					980	my $str = $_[1];
849	567					940	my $pos = $_[2];
850	567					740	(my $MATCH);
851	567					2564	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
852	567					1041	(($MATCH)->{bool} = ((do {
853	567					2354	((my $pos1) = $MATCH->to());
854	567					867	(do {
855	567					1709	((my $last_pos) = $MATCH->to());
856	567	100				1007	if (!((do {
857	567					2646	((my $pos1) = $MATCH->to());
858							((((do {
859	567	100				1792	(('.' eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))
860							}) \|\| (do {
861	562					1182	(($MATCH)->{to} = $pos1);
862	562	50				1752	((((chr(33) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
863							})) \|\| (do {
864	562					1191	(($MATCH)->{to} = $pos1);
865	562	50				1888	((((chr(94) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
866	567	50	66			984	})) \|\| (do {
			33
867	562					1038	(($MATCH)->{to} = $pos1);
868	562	50				1868	(((('*' eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
869							}))
870							}))) {
871	562					1206	(($MATCH)->{to} = $last_pos)
872							};
873	567					1951	1
874							})
875							})));
876	567					1301	$MATCH
877							};
878							sub var_name {
879	565			565	0	1150	my $grammar = $_[0];
880	565					1141	my $str = $_[1];
881	565					872	my $pos = $_[2];
882	565					746	(my $MATCH);
883	565					2473	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
884	565					1001	(($MATCH)->{bool} = ((do {
885	565					1872	((my $pos1) = $MATCH->to());
886							(((do {
887	565					1885	((my $m2) = $grammar->full_ident($str, $MATCH->to()));
888	565	100				1837	if ($m2) {
889	541					1768	(($MATCH)->{to} = $m2->to());
890	541					1423	($MATCH->{'full_ident'} = $m2);
891	541					2184	1
892							}
893							else {
894	24					143	0
895							}
896							}) \|\| (do {
897	24					52	(($MATCH)->{to} = $pos1);
898	24	50				92	((((chr(47) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
899	565	50	66			893	})) \|\| (do {
900	24					54	(($MATCH)->{to} = $pos1);
901	24					38	((do {
902	24					89	((my $m2) = $grammar->digit($str, $MATCH->to()));
903	24	50				74	if ($m2) {
904	0					0	(($MATCH)->{to} = $m2->to());
905	0					0	($MATCH->{'digit'} = $m2);
906	0					0	1
907							}
908							else {
909	24					89	0
910							}
911							}))
912							}))
913							})));
914	565					1321	$MATCH
915							};
916							sub var_ident {
917	5564			5564	0	12473	my $grammar = $_[0];
918	5564					8953	my $str = $_[1];
919	5564					6904	my $pos = $_[2];
920	5564					6822	(my $MATCH);
921	5564					21298	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
922	5564					8113	(($MATCH)->{bool} = ((do {
923	5564					15190	((my $pos1) = $MATCH->to());
924	5564					7175	(do {
925							(((((do {
926	5564					15688	((my $m2) = $grammar->var_sigil($str, $MATCH->to()));
927	5564	100				17450	if ($m2) {
928	565					3585	(($MATCH)->{to} = $m2->to());
929	565					1432	($MATCH->{'var_sigil'} = $m2);
930	565					29423	1
931							}
932							else {
933	4999					25439	0
934							}
935							}) && (do {
936	565					2018	((my $m2) = $grammar->var_twigil($str, $MATCH->to()));
937	565	50				1698	if ($m2) {
938	565					1829	(($MATCH)->{to} = $m2->to());
939	565					1542	($MATCH->{'var_twigil'} = $m2);
940	565					2752	1
941							}
942							else {
943	0					0	0
944							}
945							})) && (do {
946	565					2070	((my $m2) = $grammar->optional_namespace_before_ident($str, $MATCH->to()));
947	565	50				1891	if ($m2) {
948	565					1879	(($MATCH)->{to} = $m2->to());
949	565					1531	($MATCH->{'optional_namespace_before_ident'} = $m2);
950	565					2361	1
951							}
952							else {
953	0					0	0
954							}
955							})) && (do {
956	565					2179	((my $m2) = $grammar->var_name($str, $MATCH->to()));
957	565	100				5371	if ($m2) {
958	541					1870	(($MATCH)->{to} = $m2->to());
959	541					2162	($MATCH->{'var_name'} = $m2);
960	541					2418	1
961							}
962							else {
963	24					129	0
964							}
965	5564	100	50			6448	})) && (((do {
			66
			33
			33
966	541					2650	($MATCH->{capture} = (Var->new(('sigil' => "".($MATCH->{'var_sigil'})), ('twigil' => "".($MATCH->{'var_twigil'})), ('namespace' => ${$MATCH->{'optional_namespace_before_ident'}}), ('name' => "".($MATCH->{'var_name'})))))
	541					3700
967							}) \|\| 1)))
968							})
969							})));
970	5564					31409	$MATCH
971							};
972							sub exponent {
973	336			336	0	734	my $grammar = $_[0];
974	336					570	my $str = $_[1];
975	336					566	my $pos = $_[2];
976	336					490	(my $MATCH);
977	336					1448	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
978	336					625	(($MATCH)->{bool} = ((do {
979	336					1098	((my $pos1) = $MATCH->to());
980	336					483	(do {
981							(((do {
982	336					1234	((my $pos1) = $MATCH->to());
983							((do {
984	336	50				1110	(('e' eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))
985	336	50				552	}) \|\| (do {
986	336					741	(($MATCH)->{to} = $pos1);
987	336	50				1147	(((('E' eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
988							}))
989							}) && (do {
990	0					0	((my $pos1) = $MATCH->to());
991							(((do {
992	0	0				0	(('+' eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))
993							}) \|\| (do {
994	0					0	(($MATCH)->{to} = $pos1);
995	0	0				0	(((('-' eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
996	0	0	0			0	})) \|\| (do {
997	0					0	(($MATCH)->{to} = $pos1);
998	0					0	(1)
999							}))
1000	336	0	33			975	})) && (do {
1001	0					0	((my $last_match_null) = 0);
1002	0					0	((my $last_pos) = $MATCH->to());
1003	0					0	((my $count) = 0);
1004	0		0			0	for ( ; ((do {
1005	0					0	((my $m2) = $grammar->digit($str, $MATCH->to()));
1006	0	0				0	if ($m2) {
1007	0					0	(($MATCH)->{to} = $m2->to());
1008	0					0	1
1009							}
1010							else {
1011	0					0	0
1012							}
1013							}) && (($last_match_null < 2))); ) {
1014	0	0				0	if (($last_pos == $MATCH->to())) {
1015	0					0	($last_match_null = ($last_match_null + 1))
1016							}
1017							else {
1018	0					0	($last_match_null = 0)
1019							};
1020	0					0	($last_pos = $MATCH->to());
1021	0					0	($count = ($count + 1))
1022							};
1023	0					0	(($MATCH)->{to} = $last_pos);
1024	0					0	($count > 0)
1025							}))
1026							})
1027							})));
1028	336					928	$MATCH
1029							};
1030							sub val_num {
1031	2337			2337	0	4151	my $grammar = $_[0];
1032	2337					3622	my $str = $_[1];
1033	2337					3594	my $pos = $_[2];
1034	2337					4288	(my $MATCH);
1035	2337					9367	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
1036	2337					4089	(($MATCH)->{bool} = ((do {
1037	2337					8104	((my $pos1) = $MATCH->to());
1038	2337					3538	(do {
1039							((do {
1040	2337					7362	((my $pos1) = $MATCH->to());
1041							((do {
1042							((((('.' eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (do {
1043	0					0	((my $last_match_null) = 0);
1044	0					0	((my $last_pos) = $MATCH->to());
1045	0					0	((my $count) = 0);
1046	0		0			0	for ( ; ((do {
1047	0					0	((my $m2) = $grammar->digit($str, $MATCH->to()));
1048	0	0				0	if ($m2) {
1049	0					0	(($MATCH)->{to} = $m2->to());
1050	0					0	1
1051							}
1052							else {
1053	0					0	0
1054							}
1055							}) && (($last_match_null < 2))); ) {
1056	0	0				0	if (($last_pos == $MATCH->to())) {
1057	0					0	($last_match_null = ($last_match_null + 1))
1058							}
1059							else {
1060	0					0	($last_match_null = 0)
1061							};
1062	0					0	($last_pos = $MATCH->to());
1063	0					0	($count = ($count + 1))
1064							};
1065	0					0	(($MATCH)->{to} = $last_pos);
1066	0					0	($count > 0)
1067	2337	0	33			8176	})) && (do {
			33
1068	0					0	((my $last_pos) = $MATCH->to());
1069	0	0				0	if (!((do {
1070	0					0	((my $m2) = $grammar->exponent($str, $MATCH->to()));
1071	0	0				0	if ($m2) {
1072	0					0	(($MATCH)->{to} = $m2->to());
1073	0					0	1
1074							}
1075							else {
1076	0					0	0
1077							}
1078							}))) {
1079	0					0	(($MATCH)->{to} = $last_pos)
1080							};
1081	0					0	1
1082							}))
1083	2337	50				3735	}) \|\| (do {
1084	2337					4522	(($MATCH)->{to} = $pos1);
1085							(((do {
1086	2337					3650	((my $last_match_null) = 0);
1087	2337					6869	((my $last_pos) = $MATCH->to());
1088	2337					3876	((my $count) = 0);
1089	2337		66			3363	for ( ; ((do {
1090	2689					8001	((my $m2) = $grammar->digit($str, $MATCH->to()));
1091	2689	100				9136	if ($m2) {
1092	352					1500	(($MATCH)->{to} = $m2->to());
1093	352					2561	1
1094							}
1095							else {
1096	2337					12826	0
1097							}
1098							}) && (($last_match_null < 2))); ) {
1099	352	50				1221	if (($last_pos == $MATCH->to())) {
1100	0					0	($last_match_null = ($last_match_null + 1))
1101							}
1102							else {
1103	352					643	($last_match_null = 0)
1104							};
1105	352					1608	($last_pos = $MATCH->to());
1106	352					573	($count = ($count + 1))
1107							};
1108	2337					4389	(($MATCH)->{to} = $last_pos);
1109	2337					13672	($count > 0)
1110	2337	100				3145	}) && (do {
1111	327					1084	((my $pos1) = $MATCH->to());
1112							((do {
1113	327					1185	((my $m2) = $grammar->exponent($str, $MATCH->to()));
1114	327	50				1011	if ($m2) {
1115	0					0	(($MATCH)->{to} = $m2->to());
1116	0					0	1
1117							}
1118							else {
1119	327					2157	0
1120							}
1121	327	50				592	}) \|\| (do {
1122	327					642	(($MATCH)->{to} = $pos1);
1123							(((((('.' eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (do {
1124	9					19	((my $last_match_null) = 0);
1125	9					44	((my $last_pos) = $MATCH->to());
1126	9					19	((my $count) = 0);
1127	9		66			17	for ( ; ((do {
1128	25					68	((my $m2) = $grammar->digit($str, $MATCH->to()));
1129	25	100				78	if ($m2) {
1130	16					61	(($MATCH)->{to} = $m2->to());
1131	16					125	1
1132							}
1133							else {
1134	9					41	0
1135							}
1136							}) && (($last_match_null < 2))); ) {
1137	16	50				54	if (($last_pos == $MATCH->to())) {
1138	0					0	($last_match_null = ($last_match_null + 1))
1139							}
1140							else {
1141	16					27	($last_match_null = 0)
1142							};
1143	16					45	($last_pos = $MATCH->to());
1144	16					28	($count = ($count + 1))
1145							};
1146	9					23	(($MATCH)->{to} = $last_pos);
1147	9					50	($count > 0)
1148	327	50	66			1056	})) && (do {
			66
1149	9					35	((my $last_pos) = $MATCH->to());
1150	9	50				15	if (!((do {
1151	9					31	((my $m2) = $grammar->exponent($str, $MATCH->to()));
1152	9	50				36	if ($m2) {
1153	0					0	(($MATCH)->{to} = $m2->to());
1154	0					0	1
1155							}
1156							else {
1157	9					45	0
1158							}
1159							}))) {
1160	9					888	(($MATCH)->{to} = $last_pos)
1161							};
1162	9					53	1
1163							})))
1164							}))
1165							})))
1166							}))
1167	2337	100	50			2927	}) && (((do {
1168	9					44	($MATCH->{capture} = (Val::Num->new(('num' => "".($MATCH)))))
1169							}) \|\| 1)))
1170							})
1171							})));
1172	2337					8040	$MATCH
1173							};
1174							sub char_any {
1175	0			0	0	0	my $grammar = $_[0];
1176	0					0	my $str = $_[1];
1177	0					0	my $pos = $_[2];
1178	0					0	(my $MATCH);
1179	0					0	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
1180	0					0	(($MATCH)->{bool} = ((do {
1181	0					0	((my $pos1) = $MATCH->to());
1182	0					0	(do {
1183	0	0				0	(('' ne substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))
1184							})
1185							})));
1186	0					0	$MATCH
1187							};
1188							sub char_any_single_quote {
1189	549			549	0	988	my $grammar = $_[0];
1190	549					836	my $str = $_[1];
1191	549					2155	my $pos = $_[2];
1192	549					638	(my $MATCH);
1193	549					2816	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
1194	549					878	(($MATCH)->{bool} = ((do {
1195	549					1671	((my $pos1) = $MATCH->to());
1196	549					885	(do {
1197							(((do {
1198	549					794	((my $tmp) = $MATCH);
1199	549					1767	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $tmp->to()), ('to' => $tmp->to()), ('bool' => 1)));
1200	549					919	(($MATCH)->{bool} = (do {
1201	549					1540	((my $pos1) = $MATCH->to());
1202	549					724	(do {
1203	549	100				1635	((chr(39) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))
1204							})
1205							}));
1206	549					1641	(($tmp)->{bool} = !($MATCH));
1207	549					942	($MATCH = $tmp);
1208	549					1791	!!($MATCH)
1209	549	50	33			736	}) && ((('' ne substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to())))))) && (do {
			66
1210	274					819	((my $last_match_null) = 0);
1211	274					856	((my $last_pos) = $MATCH->to());
1212	274		66			534	for ( ; ((do {
1213	1955					4998	((my $pos1) = $MATCH->to());
1214	1955					2250	(do {
1215	1955	100	33			2111	((do {
1216	1955					2584	((my $tmp) = $MATCH);
1217	1955					5097	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $tmp->to()), ('to' => $tmp->to()), ('bool' => 1)));
1218	1955					2690	(($MATCH)->{bool} = (do {
1219	1955					9954	((my $pos1) = $MATCH->to());
1220	1955					2447	(do {
1221	1955					5495	((my $pos1) = $MATCH->to());
1222							((do {
1223	1955	100				4749	((chr(39) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))
1224	1955	100				2462	}) \|\| (do {
1225	1681					2771	(($MATCH)->{to} = $pos1);
1226	1681	50				4107	((((chr(92) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
1227							}))
1228							})
1229							}));
1230	1955					5358	(($tmp)->{bool} = !($MATCH));
1231	1955					3316	($MATCH = $tmp);
1232	1955					7335	!!($MATCH)
1233							}) && ((('' ne substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
1234							})
1235							}) && (($last_match_null < 2))); ) {
1236	1681	50				10863	if (($last_pos == $MATCH->to())) {
1237	0					0	($last_match_null = ($last_match_null + 1))
1238							}
1239							else {
1240	1681					2265	($last_match_null = 0)
1241							};
1242	1681					4277	($last_pos = $MATCH->to())
1243							};
1244	274					778	(($MATCH)->{to} = $last_pos);
1245	274					695	1
1246							}))
1247							})
1248							})));
1249	549					1524	$MATCH
1250							};
1251							sub single_quoted_unescape {
1252	549			549	0	1055	my $grammar = $_[0];
1253	549					797	my $str = $_[1];
1254	549					822	my $pos = $_[2];
1255	549					1265	(my $MATCH);
1256	549					2290	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
1257	549					940	(($MATCH)->{bool} = ((do {
1258	549					1885	((my $pos1) = $MATCH->to());
1259							(((((do {
1260							((((((chr(92) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (((chr(92) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to())))))) && (do {
1261	0					0	((my $m2) = $grammar->single_quoted_unescape($str, $MATCH->to()));
1262	0	0				0	if ($m2) {
1263	0					0	(($MATCH)->{to} = $m2->to());
1264	0					0	($MATCH->{'single_quoted_unescape'} = $m2);
1265	0					0	1
1266							}
1267							else {
1268	0					0	0
1269							}
1270	549	0	0			1546	})) && (((do {
			33
			0
			33
			0
1271	0					0	($MATCH->{capture} = ((chr(92) . $MATCH->{'single_quoted_unescape'})))
1272							}) \|\| 1)))
1273							}) \|\| (do {
1274	549					1220	(($MATCH)->{to} = $pos1);
1275							(((((((chr(92) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (((chr(39) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to())))))) && (do {
1276	0					0	((my $m2) = $grammar->single_quoted_unescape($str, $MATCH->to()));
1277	0	0				0	if ($m2) {
1278	0					0	(($MATCH)->{to} = $m2->to());
1279	0					0	($MATCH->{'single_quoted_unescape'} = $m2);
1280	0					0	1
1281							}
1282							else {
1283	0					0	0
1284							}
1285	549	0	0			1659	})) && (((do {
			33
			0
			33
			0
1286	0					0	($MATCH->{capture} = ((chr(39) . $MATCH->{'single_quoted_unescape'})))
1287							}) \|\| 1))))
1288							})) \|\| (do {
1289	549					1017	(($MATCH)->{to} = $pos1);
1290							((((((chr(92) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (do {
1291	0					0	((my $m2) = $grammar->single_quoted_unescape($str, $MATCH->to()));
1292	0	0				0	if ($m2) {
1293	0					0	(($MATCH)->{to} = $m2->to());
1294	0					0	($MATCH->{'single_quoted_unescape'} = $m2);
1295	0					0	1
1296							}
1297							else {
1298	0					0	0
1299							}
1300	549	0	0			1575	})) && (((do {
			33
			33
1301	0					0	($MATCH->{capture} = ((chr(92) . $MATCH->{'single_quoted_unescape'})))
1302							}) \|\| 1))))
1303							})) \|\| (do {
1304	549					1047	(($MATCH)->{to} = $pos1);
1305							((((do {
1306	549					1642	((my $m2) = $grammar->char_any_single_quote($str, $MATCH->to()));
1307	549	100				1520	if ($m2) {
1308	274					910	(($MATCH)->{to} = $m2->to());
1309	274					742	($MATCH->{'char_any_single_quote'} = $m2);
1310	274					1180	1
1311							}
1312							else {
1313	275					1853	0
1314							}
1315							}) && (do {
1316	274					1107	((my $m2) = $grammar->single_quoted_unescape($str, $MATCH->to()));
1317	274	50				807	if ($m2) {
1318	274					1117	(($MATCH)->{to} = $m2->to());
1319	274					899	($MATCH->{'single_quoted_unescape'} = $m2);
1320	274					1174	1
1321							}
1322							else {
1323	0					0	0
1324							}
1325	549	50	50			797	})) && (((do {
			66
1326	274					2574	($MATCH->{capture} = (($MATCH->{'char_any_single_quote'} . $MATCH->{'single_quoted_unescape'})))
1327							}) \|\| 1))))
1328	549	100	33			932	})) \|\| (do {
			33
			33
1329	275					626	(($MATCH)->{to} = $pos1);
1330	275					750	(1)
1331							}))
1332							})));
1333	549					2063	$MATCH
1334							};
1335							sub char_any_double_quote {
1336	283			283	0	589	my $grammar = $_[0];
1337	283					574	my $str = $_[1];
1338	283					405	my $pos = $_[2];
1339	283					390	(my $MATCH);
1340	283					1175	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
1341	283					438	(($MATCH)->{bool} = ((do {
1342	283					805	((my $pos1) = $MATCH->to());
1343	283					475	(do {
1344							(((do {
1345	283					537	((my $tmp) = $MATCH);
1346	283					2079	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $tmp->to()), ('to' => $tmp->to()), ('bool' => 1)));
1347	283					584	(($MATCH)->{bool} = (do {
1348	283					1301	((my $pos1) = $MATCH->to());
1349	283					393	(do {
1350	283					824	((my $pos1) = $MATCH->to());
1351							(((((do {
1352	283	100				742	((chr(34) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))
1353							}) \|\| (do {
1354	124					288	(($MATCH)->{to} = $pos1);
1355	124	50				424	((((chr(36) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
1356							})) \|\| (do {
1357	124					238	(($MATCH)->{to} = $pos1);
1358	124	50				403	((((chr(64) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
1359							})) \|\| (do {
1360	124					266	(($MATCH)->{to} = $pos1);
1361	124	50				435	((((chr(37) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
1362	283	50	66			696	})) \|\| (do {
			33
			33
1363	124					245	(($MATCH)->{to} = $pos1);
1364	124	50				406	((((chr(123) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
1365							}))
1366							})
1367							}));
1368	283					968	(($tmp)->{bool} = !($MATCH));
1369	283					581	($MATCH = $tmp);
1370	283					977	!!($MATCH)
1371	283	50	33			466	}) && ((('' ne substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to())))))) && (do {
			66
1372	124					257	((my $last_match_null) = 0);
1373	124					389	((my $last_pos) = $MATCH->to());
1374	124		66			667	for ( ; ((do {
1375	890					2499	((my $pos1) = $MATCH->to());
1376	890					1089	(do {
1377	890	100	33			1068	((do {
1378	890					1160	((my $tmp) = $MATCH);
1379	890					2463	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $tmp->to()), ('to' => $tmp->to()), ('bool' => 1)));
1380	890					1851	(($MATCH)->{bool} = (do {
1381	890					2532	((my $pos1) = $MATCH->to());
1382	890					1045	(do {
1383	890					2564	((my $pos1) = $MATCH->to());
1384							((((((do {
1385	890	100				2245	((chr(34) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))
1386							}) \|\| (do {
1387	773					1387	(($MATCH)->{to} = $pos1);
1388	773	100				1919	((((chr(36) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
1389							})) \|\| (do {
1390	771					1222	(($MATCH)->{to} = $pos1);
1391	771	50				7781	((((chr(64) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
1392							})) \|\| (do {
1393	771					1253	(($MATCH)->{to} = $pos1);
1394	771	50				2022	((((chr(37) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
1395							})) \|\| (do {
1396	771					1249	(($MATCH)->{to} = $pos1);
1397	771	100				2316	((((chr(123) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
1398	890	100	66			1036	})) \|\| (do {
			66
			33
			33
1399	768					1206	(($MATCH)->{to} = $pos1);
1400	768	100				1861	((((chr(92) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
1401							}))
1402							})
1403							}));
1404	890					3171	(($tmp)->{bool} = !($MATCH));
1405	890					1514	($MATCH = $tmp);
1406	890					7657	!!($MATCH)
1407							}) && ((('' ne substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))))
1408							})
1409							}) && (($last_match_null < 2))); ) {
1410	766	50				2378	if (($last_pos == $MATCH->to())) {
1411	0					0	($last_match_null = ($last_match_null + 1))
1412							}
1413							else {
1414	766					1210	($last_match_null = 0)
1415							};
1416	766					1962	($last_pos = $MATCH->to())
1417							};
1418	124					314	(($MATCH)->{to} = $last_pos);
1419	124					313	1
1420							}))
1421							})
1422							})));
1423	283					878	$MATCH
1424							};
1425							sub double_quoted_unescape {
1426	285			285	0	610	my $grammar = $_[0];
1427	285					410	my $str = $_[1];
1428	285					380	my $pos = $_[2];
1429	285					385	(my $MATCH);
1430	285					1569	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
1431	285					512	(($MATCH)->{bool} = ((do {
1432	285					1001	((my $pos1) = $MATCH->to());
1433							((do {
1434	285	100	66			831	((((chr(92) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (do {
1435	2					8	((my $pos1) = $MATCH->to());
1436							(((((do {
1437	2	50	33			7	(((('c' eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (do {
1438	0					0	((my $pos1) = $MATCH->to());
1439							((do {
1440							(((((('[' eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (do {
1441	0					0	((my $m2) = $grammar->digits($str, $MATCH->to()));
1442	0	0				0	if ($m2) {
1443	0					0	(($MATCH)->{to} = $m2->to());
1444	0					0	($MATCH->{'digits'} = $m2);
1445	0					0	1
1446							}
1447							else {
1448	0					0	0
1449							}
1450	0	0	0			0	})) && (((']' eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to())))))) && (((do {
			0
			0
			0
			0
1451	0					0	($MATCH->{capture} = (chr($MATCH->{'digits'})))
1452							}) \|\| 1)))
1453	0	0				0	}) \|\| (do {
1454	0					0	(($MATCH)->{to} = $pos1);
1455							(((do {
1456	0					0	((my $m2) = $grammar->digits($str, $MATCH->to()));
1457	0	0				0	if ($m2) {
1458	0					0	(($MATCH)->{to} = $m2->to());
1459	0					0	($MATCH->{'digits'} = $m2);
1460	0					0	1
1461							}
1462							else {
1463	0					0	0
1464							}
1465	0	0	0			0	}) && (((do {
1466	0					0	($MATCH->{capture} = (chr($MATCH->{'digits'})))
1467							}) \|\| 1))))
1468							}))
1469							}))
1470							}) \|\| (do {
1471	2					4	(($MATCH)->{to} = $pos1);
1472	2	50	0			8	((((('e' eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (((do {
			33
1473	0					0	($MATCH->{capture} = (chr(27)))
1474							}) \|\| 1))))
1475							})) \|\| (do {
1476	2					5	(($MATCH)->{to} = $pos1);
1477	2	50	50			7	((((('n' eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (((do {
			33
1478	2					18	($MATCH->{capture} = ((chr(10))))
1479							}) \|\| 1))))
1480							})) \|\| (do {
1481	0					0	(($MATCH)->{to} = $pos1);
1482	0	0	0			0	((((('t' eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (((do {
			0
1483	0					0	($MATCH->{capture} = (chr(9)))
1484							}) \|\| 1))))
1485	2	0	33			5	})) \|\| (do {
			33
			33
1486	0					0	(($MATCH)->{to} = $pos1);
1487							(((do {
1488	0					0	((my $m2) = $grammar->char_any($str, $MATCH->to()));
1489	0	0				0	if ($m2) {
1490	0					0	(($MATCH)->{to} = $m2->to());
1491	0					0	($MATCH->{'char_any'} = $m2);
1492	0					0	1
1493							}
1494							else {
1495	0					0	0
1496							}
1497	0	0	0			0	}) && (((do {
1498	0					0	($MATCH->{capture} = ("".($MATCH->{'char_any'})))
1499							}) \|\| 1))))
1500							}))
1501							}))
1502	285	100				436	}) \|\| (do {
1503	283					547	(($MATCH)->{to} = $pos1);
1504							(((do {
1505	283					960	((my $m2) = $grammar->char_any_double_quote($str, $MATCH->to()));
1506	283	100				819	if ($m2) {
1507	124					405	(($MATCH)->{to} = $m2->to());
1508	124					341	($MATCH->{'char_any_double_quote'} = $m2);
1509	124					552	1
1510							}
1511							else {
1512	159					898	0
1513							}
1514	283	100	100			380	}) && (((do {
1515	124					628	($MATCH->{capture} = ("".($MATCH->{'char_any_double_quote'})))
1516							}) \|\| 1))))
1517							}))
1518							})));
1519	285					890	$MATCH
1520							};
1521							sub double_quoted_buf {
1522	290			290	0	816	my $grammar = $_[0];
1523	290					484	my $str = $_[1];
1524	290					511	my $pos = $_[2];
1525	290					317	(my $MATCH);
1526	290					1392	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
1527	290					506	(($MATCH)->{bool} = ((do {
1528	290					1052	((my $pos1) = $MATCH->to());
1529							(((((do {
1530							((do {
1531	290					638	((my $tmp) = $MATCH);
1532	290					1010	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $tmp->to()), ('to' => $tmp->to()), ('bool' => 1)));
1533	290					670	(($MATCH)->{bool} = (do {
1534	290					897	((my $pos1) = $MATCH->to());
1535	290					389	(do {
1536	290	100				1064	((chr(36) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))
1537							})
1538							}));
1539	290					847	(($tmp)->{bool} = !!($MATCH));
1540	290					584	($MATCH = $tmp);
1541	290					961	!!($MATCH)
1542	290	100				436	}) && (do {
1543	2					9	((my $pos1) = $MATCH->to());
1544							((do {
1545							(((do {
1546	2					4	((my $tmp) = $MATCH);
1547	2					9	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $tmp->to()), ('to' => $tmp->to()), ('bool' => 1)));
1548	2					4	(($MATCH)->{bool} = (do {
1549	2					10	((my $pos1) = $MATCH->to());
1550	2					2	(do {
1551							(((((chr(36) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (do {
1552	2					7	((my $m2) = $grammar->var_twigil($str, $MATCH->to()));
1553	2	50				6	if ($m2) {
1554	2					7	(($MATCH)->{to} = $m2->to());
1555	2					9	1
1556							}
1557							else {
1558	0					0	0
1559							}
1560	2	50	33			6	})) && (do {
			33
1561	2					7	((my $m2) = $grammar->ident($str, $MATCH->to()));
1562	2	50				7	if ($m2) {
1563	2					9	(($MATCH)->{to} = $m2->to());
1564	2					7	1
1565							}
1566							else {
1567	0					0	0
1568							}
1569							}))
1570							})
1571							}));
1572	2					7	(($tmp)->{bool} = !!($MATCH));
1573	2					3	($MATCH = $tmp);
1574	2					7	!!($MATCH)
1575							}) && (do {
1576	2					8	((my $m2) = Perlito::Expression->operator($str, $MATCH->to()));
1577	2	50				6	if ($m2) {
1578	2					9	(($MATCH)->{to} = $m2->to());
1579	2					4	($MATCH->{'Perlito::Expression.operator'} = $m2);
1580	2					11	1
1581							}
1582							else {
1583	0					0	0
1584							}
1585	2	50	50			3	})) && (((do {
			33
1586	2					3	($MATCH->{capture} = ((${$MATCH->{'Perlito::Expression.operator'}})->[1]))
	2					9
1587							}) \|\| 1)))
1588	2	50				4	}) \|\| (do {
1589	0					0	(($MATCH)->{to} = $pos1);
1590							(((do {
1591	0					0	((my $m2) = $grammar->char_any($str, $MATCH->to()));
1592	0	0				0	if ($m2) {
1593	0					0	(($MATCH)->{to} = $m2->to());
1594	0					0	($MATCH->{'char_any'} = $m2);
1595	0					0	1
1596							}
1597							else {
1598	0					0	0
1599							}
1600	0	0	0			0	}) && (((do {
1601	0					0	($MATCH->{capture} = (Val::Buf->new(('buf' => "".($MATCH->{'char_any'})))))
1602							}) \|\| 1))))
1603							}))
1604							}))
1605							}) \|\| (do {
1606	288					571	(($MATCH)->{to} = $pos1);
1607							(((do {
1608	288					488	((my $tmp) = $MATCH);
1609	288					984	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $tmp->to()), ('to' => $tmp->to()), ('bool' => 1)));
1610	288					522	(($MATCH)->{bool} = (do {
1611	288					931	((my $pos1) = $MATCH->to());
1612	288					381	(do {
1613	288	50				922	((chr(64) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))
1614							})
1615							}));
1616	288					796	(($tmp)->{bool} = !!($MATCH));
1617	288					716	($MATCH = $tmp);
1618	288					975	!!($MATCH)
1619	288	50				423	}) && (do {
1620	0					0	((my $pos1) = $MATCH->to());
1621							((do {
1622							((((do {
1623	0					0	((my $tmp) = $MATCH);
1624	0					0	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $tmp->to()), ('to' => $tmp->to()), ('bool' => 1)));
1625	0					0	(($MATCH)->{bool} = (do {
1626	0					0	((my $pos1) = $MATCH->to());
1627	0					0	(do {
1628							(((((chr(64) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (do {
1629	0					0	((my $m2) = $grammar->var_twigil($str, $MATCH->to()));
1630	0	0				0	if ($m2) {
1631	0					0	(($MATCH)->{to} = $m2->to());
1632	0					0	1
1633							}
1634							else {
1635	0					0	0
1636							}
1637	0	0	0			0	})) && (do {
			0
1638	0					0	((my $m2) = $grammar->ident($str, $MATCH->to()));
1639	0	0				0	if ($m2) {
1640	0					0	(($MATCH)->{to} = $m2->to());
1641	0					0	1
1642							}
1643							else {
1644	0					0	0
1645							}
1646							}))
1647							})
1648							}));
1649	0					0	(($tmp)->{bool} = !!($MATCH));
1650	0					0	($MATCH = $tmp);
1651	0					0	!!($MATCH)
1652							}) && (do {
1653	0					0	((my $m2) = Perlito::Expression->operator($str, $MATCH->to()));
1654	0	0				0	if ($m2) {
1655	0					0	(($MATCH)->{to} = $m2->to());
1656	0					0	($MATCH->{'Perlito::Expression.operator'} = $m2);
1657	0					0	1
1658							}
1659							else {
1660	0					0	0
1661							}
1662	0	0	0			0	})) && ((('[]' eq substr($str, $MATCH->to(), 2)) && ((($MATCH)->{to} = (2 + $MATCH->to())))))) && (((do {
			0
			0
			0
1663	0					0	($MATCH->{capture} = ((${$MATCH->{'Perlito::Expression.operator'}})->[1]))
	0					0
1664							}) \|\| 1)))
1665	0	0				0	}) \|\| (do {
1666	0					0	(($MATCH)->{to} = $pos1);
1667							(((do {
1668	0					0	((my $m2) = $grammar->char_any($str, $MATCH->to()));
1669	0	0				0	if ($m2) {
1670	0					0	(($MATCH)->{to} = $m2->to());
1671	0					0	($MATCH->{'char_any'} = $m2);
1672	0					0	1
1673							}
1674							else {
1675	0					0	0
1676							}
1677	0	0	0			0	}) && (((do {
1678	0					0	($MATCH->{capture} = (Val::Buf->new(('buf' => "".($MATCH->{'char_any'})))))
1679							}) \|\| 1))))
1680							}))
1681							})))
1682							})) \|\| (do {
1683	288					574	(($MATCH)->{to} = $pos1);
1684							(((do {
1685	288					501	((my $tmp) = $MATCH);
1686	288					979	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $tmp->to()), ('to' => $tmp->to()), ('bool' => 1)));
1687	288					492	(($MATCH)->{bool} = (do {
1688	288					872	((my $pos1) = $MATCH->to());
1689	288					645	(do {
1690	288	50				882	((chr(37) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))
1691							})
1692							}));
1693	288					1465	(($tmp)->{bool} = !!($MATCH));
1694	288					475	($MATCH = $tmp);
1695	288					1195	!!($MATCH)
1696	288	50				385	}) && (do {
1697	0					0	((my $pos1) = $MATCH->to());
1698							((do {
1699							((((do {
1700	0					0	((my $tmp) = $MATCH);
1701	0					0	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $tmp->to()), ('to' => $tmp->to()), ('bool' => 1)));
1702	0					0	(($MATCH)->{bool} = (do {
1703	0					0	((my $pos1) = $MATCH->to());
1704	0					0	(do {
1705							(((((chr(37) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (do {
1706	0					0	((my $m2) = $grammar->var_twigil($str, $MATCH->to()));
1707	0	0				0	if ($m2) {
1708	0					0	(($MATCH)->{to} = $m2->to());
1709	0					0	1
1710							}
1711							else {
1712	0					0	0
1713							}
1714	0	0	0			0	})) && (do {
			0
1715	0					0	((my $m2) = $grammar->ident($str, $MATCH->to()));
1716	0	0				0	if ($m2) {
1717	0					0	(($MATCH)->{to} = $m2->to());
1718	0					0	1
1719							}
1720							else {
1721	0					0	0
1722							}
1723							}))
1724							})
1725							}));
1726	0					0	(($tmp)->{bool} = !!($MATCH));
1727	0					0	($MATCH = $tmp);
1728	0					0	!!($MATCH)
1729							}) && (do {
1730	0					0	((my $m2) = Perlito::Expression->operator($str, $MATCH->to()));
1731	0	0				0	if ($m2) {
1732	0					0	(($MATCH)->{to} = $m2->to());
1733	0					0	($MATCH->{'Perlito::Expression.operator'} = $m2);
1734	0					0	1
1735							}
1736							else {
1737	0					0	0
1738							}
1739	0	0	0			0	})) && (((chr(123) . chr(125) eq substr($str, $MATCH->to(), 2)) && ((($MATCH)->{to} = (2 + $MATCH->to())))))) && (((do {
			0
			0
			0
1740	0					0	($MATCH->{capture} = ((${$MATCH->{'Perlito::Expression.operator'}})->[1]))
	0					0
1741							}) \|\| 1)))
1742	0	0				0	}) \|\| (do {
1743	0					0	(($MATCH)->{to} = $pos1);
1744							(((do {
1745	0					0	((my $m2) = $grammar->char_any($str, $MATCH->to()));
1746	0	0				0	if ($m2) {
1747	0					0	(($MATCH)->{to} = $m2->to());
1748	0					0	($MATCH->{'char_any'} = $m2);
1749	0					0	1
1750							}
1751							else {
1752	0					0	0
1753							}
1754	0	0	0			0	}) && (((do {
1755	0					0	($MATCH->{capture} = (Val::Buf->new(('buf' => "".($MATCH->{'char_any'})))))
1756							}) \|\| 1))))
1757							}))
1758							})))
1759							})) \|\| (do {
1760	288					763	(($MATCH)->{to} = $pos1);
1761							(((((((chr(123) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (do {
1762	3					15	((my $m2) = $grammar->exp_stmts($str, $MATCH->to()));
1763	3	50				9	if ($m2) {
1764	3					11	(($MATCH)->{to} = $m2->to());
1765	3					10	($MATCH->{'exp_stmts'} = $m2);
1766	3					24	1
1767							}
1768							else {
1769	0					0	0
1770							}
1771	288	50	50			868	})) && (((chr(125) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to())))))) && (((do {
			66
			66
			33
			33
1772	3					9	($MATCH->{capture} = (Do->new(('block' => Lit::Block->new(('stmts' => ${$MATCH->{'exp_stmts'}}))))))
	3					11
1773							}) \|\| 1))))
1774	290	100	66			733	})) \|\| (do {
			33
			33
1775	285					544	(($MATCH)->{to} = $pos1);
1776							(((do {
1777	285					894	((my $m2) = $grammar->double_quoted_unescape($str, $MATCH->to()));
1778	285	100				847	if ($m2) {
1779	126					449	(($MATCH)->{to} = $m2->to());
1780	126					302	($MATCH->{'double_quoted_unescape'} = $m2);
1781	126					555	1
1782							}
1783							else {
1784	159					725	0
1785							}
1786	285	100	50			437	}) && (((do {
1787	126					210	($MATCH->{capture} = (Val::Buf->new(('buf' => ${$MATCH->{'double_quoted_unescape'}}))))
	126					457
1788							}) \|\| 1))))
1789							}))
1790							})));
1791	290					1097	$MATCH
1792							};
1793							sub val_buf {
1794	2010			2010	0	3439	my $grammar = $_[0];
1795	2010					3143	my $str = $_[1];
1796	2010					2987	my $pos = $_[2];
1797	2010					2365	(my $MATCH);
1798	2010					9003	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
1799	2010					3374	(($MATCH)->{bool} = ((do {
1800	2010					6790	((my $pos1) = $MATCH->to());
1801							((do {
1802							((((((chr(34) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (do {
1803	159					323	((my $last_match_null) = 0);
1804	159					608	((my $last_pos) = $MATCH->to());
1805	159		66			309	for ( ; ((do {
1806	290					960	((my $m2) = $grammar->double_quoted_buf($str, $MATCH->to()));
1807	290	100				854	if ($m2) {
1808	131					431	(($MATCH)->{to} = $m2->to());
1809	131	100				481	if (exists($MATCH->{'double_quoted_buf'})) {
1810	10					18	push( @{($MATCH->{'double_quoted_buf'})}, $m2 )
	10					38
1811							}
1812							else {
1813	121					192	($MATCH->{'double_quoted_buf'} = do {
1814	121					1760	(my $List_a = bless [], 'ARRAY');
1815	121					299	(my $List_v = bless [], 'ARRAY');
1816	121					1320	push( @{$List_a}, $m2 );
	121					296
1817	121					440	$List_a
1818							})
1819							};
1820	131					794	1
1821							}
1822							else {
1823	159					777	0
1824							}
1825							}) && (($last_match_null < 2))); ) {
1826	131	50				558	if (($last_pos == $MATCH->to())) {
1827	0					0	($last_match_null = ($last_match_null + 1))
1828							}
1829							else {
1830	131					261	($last_match_null = 0)
1831							};
1832	131					861	($last_pos = $MATCH->to())
1833							};
1834	159					358	(($MATCH)->{to} = $last_pos);
1835	159					993	1
1836	2010	50	50			8069	})) && (((chr(34) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to())))))) && (((do {
			66
			66
			33
			33
1837	159					369	((my $args) = $MATCH->{'double_quoted_buf'});
1838	159	100				526	if (!($args)) {
1839	38					272	($MATCH->{capture} = (Val::Buf->new(('buf' => ''))))
1840							}
1841							else {
1842	121					290	($MATCH->{capture} = (Apply->new(('namespace' => ''), ('code' => 'list:<' . chr(126) . '>'), ('arguments' => [ map { $_->capture() } @{( ($MATCH->{'double_quoted_buf'}) )} ]))))
	131					533
	121					428
1843							}
1844							}) \|\| 1)))
1845	2010	100				3270	}) \|\| (do {
1846	1851					3703	(($MATCH)->{to} = $pos1);
1847							(((((((chr(39) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))) && (do {
1848	275					2061	((my $m2) = $grammar->single_quoted_unescape($str, $MATCH->to()));
1849	275	50				877	if ($m2) {
1850	275					1006	(($MATCH)->{to} = $m2->to());
1851	275					712	($MATCH->{'single_quoted_unescape'} = $m2);
1852	275					1683	1
1853							}
1854							else {
1855	0					0	0
1856							}
1857	1851	50	50			5266	})) && (((chr(39) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to())))))) && (((do {
			66
			66
			33
			33
1858	275					597	($MATCH->{capture} = (Val::Buf->new(('buf' => ${$MATCH->{'single_quoted_unescape'}}))))
	275					1060
1859							}) \|\| 1))))
1860							}))
1861							})));
1862	2010					9616	$MATCH
1863							};
1864							sub digits {
1865	0			0	0	0	my $grammar = $_[0];
1866	0					0	my $str = $_[1];
1867	0					0	my $pos = $_[2];
1868	0					0	(my $MATCH);
1869	0					0	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
1870	0					0	(($MATCH)->{bool} = ((do {
1871	0					0	((my $pos1) = $MATCH->to());
1872	0					0	(do {
1873	0					0	((my $last_match_null) = 0);
1874	0					0	((my $last_pos) = $MATCH->to());
1875	0					0	((my $count) = 0);
1876	0		0			0	for ( ; ((do {
1877	0					0	((my $m2) = $grammar->digit($str, $MATCH->to()));
1878	0	0				0	if ($m2) {
1879	0					0	(($MATCH)->{to} = $m2->to());
1880	0					0	1
1881							}
1882							else {
1883	0					0	0
1884							}
1885							}) && (($last_match_null < 2))); ) {
1886	0	0				0	if (($last_pos == $MATCH->to())) {
1887	0					0	($last_match_null = ($last_match_null + 1))
1888							}
1889							else {
1890	0					0	($last_match_null = 0)
1891							};
1892	0					0	($last_pos = $MATCH->to());
1893	0					0	($count = ($count + 1))
1894							};
1895	0					0	(($MATCH)->{to} = $last_pos);
1896	0					0	($count > 0)
1897							})
1898							})));
1899	0					0	$MATCH
1900							};
1901							sub val_int {
1902	2328			2328	0	4247	my $grammar = $_[0];
1903	2328					3405	my $str = $_[1];
1904	2328					3254	my $pos = $_[2];
1905	2328					3180	(my $MATCH);
1906	2328					9601	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
1907	2328					3692	(($MATCH)->{bool} = ((do {
1908	2328					6757	((my $pos1) = $MATCH->to());
1909	2328					3468	(do {
1910							((do {
1911	2328					3534	((my $last_match_null) = 0);
1912	2328					7549	((my $last_pos) = $MATCH->to());
1913	2328					5174	((my $count) = 0);
1914	2328		66			3177	for ( ; ((do {
1915	2671					7612	((my $m2) = $grammar->digit($str, $MATCH->to()));
1916	2671	100				7769	if ($m2) {
1917	343					1186	(($MATCH)->{to} = $m2->to());
1918	343					2271	1
1919							}
1920							else {
1921	2328					11891	0
1922							}
1923							}) && (($last_match_null < 2))); ) {
1924	343	50				2660	if (($last_pos == $MATCH->to())) {
1925	0					0	($last_match_null = ($last_match_null + 1))
1926							}
1927							else {
1928	343					583	($last_match_null = 0)
1929							};
1930	343					1178	($last_pos = $MATCH->to());
1931	343					591	($count = ($count + 1))
1932							};
1933	2328					5057	(($MATCH)->{to} = $last_pos);
1934	2328					9596	($count > 0)
1935	2328	100	50			3105	}) && (((do {
1936	318					1371	($MATCH->{capture} = (Val::Int->new(('int' => "".($MATCH)))))
1937							}) \|\| 1)))
1938							})
1939							})));
1940	2328					8037	$MATCH
1941							};
1942							sub exp_stmts {
1943	270			270	0	1294	my $grammar = $_[0];
1944	270					734	my $str = $_[1];
1945	270					481	my $pos = $_[2];
1946	270					419	(my $MATCH);
1947	270					1373	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
1948	270					540	(($MATCH)->{bool} = ((do {
1949	270					961	((my $pos1) = $MATCH->to());
1950	270					473	(do {
1951							((do {
1952	270					529	((my $last_match_null) = 0);
1953	270					1178	((my $last_pos) = $MATCH->to());
1954	270		66			503	for ( ; ((do {
1955	975					3414	((my $m2) = Perlito::Expression->delimited_statement($str, $MATCH->to()));
1956	975	100				2789	if ($m2) {
1957	705					2446	(($MATCH)->{to} = $m2->to());
1958	705	100				2967	if (exists($MATCH->{'Perlito::Expression.delimited_statement'})) {
1959	436					906	push( @{($MATCH->{'Perlito::Expression.delimited_statement'})}, $m2 )
	436					2833
1960							}
1961							else {
1962	269					540	($MATCH->{'Perlito::Expression.delimited_statement'} = do {
1963	269					868	(my $List_a = bless [], 'ARRAY');
1964	269					656	(my $List_v = bless [], 'ARRAY');
1965	269					407	push( @{$List_a}, $m2 );
	269					688
1966	269					897	$List_a
1967							})
1968							};
1969	705					4452	1
1970							}
1971							else {
1972	270					1329	0
1973							}
1974							}) && (($last_match_null < 2))); ) {
1975	705	50				2542	if (($last_pos == $MATCH->to())) {
1976	0					0	($last_match_null = ($last_match_null + 1))
1977							}
1978							else {
1979	705					1689	($last_match_null = 0)
1980							};
1981	705					2305	($last_pos = $MATCH->to())
1982							};
1983	270					752	(($MATCH)->{to} = $last_pos);
1984	270					1362	1
1985	270	50	50			658	}) && (((do {
1986	270					6814	($MATCH->{capture} = ([ map { $_->capture() } @{( $MATCH->{'Perlito::Expression.delimited_statement'} )} ]))
	705					2393
	270					1058
1987							}) \|\| 1)))
1988							})
1989							})));
1990	270					1226	$MATCH
1991							};
1992							sub opt_name {
1993	28			28	0	69	my $grammar = $_[0];
1994	28					59	my $str = $_[1];
1995	28					63	my $pos = $_[2];
1996	28					39	(my $MATCH);
1997	28					124	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
1998	28					55	(($MATCH)->{bool} = ((do {
1999	28					103	((my $pos1) = $MATCH->to());
2000	28					53	(do {
2001	28					111	((my $last_pos) = $MATCH->to());
2002	28	100				50	if (!((do {
2003	28					125	((my $m2) = $grammar->ident($str, $MATCH->to()));
2004	28	100				85	if ($m2) {
2005	21					79	(($MATCH)->{to} = $m2->to());
2006	21	50				89	if (exists($MATCH->{'ident'})) {
2007	0					0	push( @{($MATCH->{'ident'})}, $m2 )
	0					0
2008							}
2009							else {
2010	21					33	($MATCH->{'ident'} = do {
2011	21					70	(my $List_a = bless [], 'ARRAY');
2012	21					52	(my $List_v = bless [], 'ARRAY');
2013	21					41	push( @{$List_a}, $m2 );
	21					50
2014	21					96	$List_a
2015							})
2016							};
2017	21					86	1
2018							}
2019							else {
2020	7					39	0
2021							}
2022							}))) {
2023	7					11	(($MATCH)->{to} = $last_pos)
2024							};
2025	28					104	1
2026							})
2027							})));
2028	28					79	$MATCH
2029							};
2030							sub var_invocant {
2031	24			24	0	60	my $grammar = $_[0];
2032	24					51	my $str = $_[1];
2033	24					47	my $pos = $_[2];
2034	24					30	(my $MATCH);
2035	24					101	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
2036	24					1066	(($MATCH)->{bool} = ((do {
2037	24					99	((my $pos1) = $MATCH->to());
2038							((do {
2039							(((do {
2040	24					92	((my $m2) = $grammar->var_ident($str, $MATCH->to()));
2041	24	100				88	if ($m2) {
2042	15					53	(($MATCH)->{to} = $m2->to());
2043	15					42	($MATCH->{'var_ident'} = $m2);
2044	15					105	1
2045							}
2046							else {
2047	9					72	0
2048							}
2049	24	100	50			33	}) && (((':' eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to())))))) && (((do {
			66
			66
2050	4					5	($MATCH->{capture} = (${$MATCH->{'var_ident'}}))
	4					16
2051							}) \|\| 1)))
2052	24	100				45	}) \|\| (do {
2053	20					54	(($MATCH)->{to} = $pos1);
2054	20	50				30	((((do {
2055	20					118	($MATCH->{capture} = (Var->new(('sigil' => chr(36)), ('twigil' => ''), ('name' => 'self'))))
2056							}) \|\| 1)))
2057							}))
2058							})));
2059	24					75	$MATCH
2060							};
2061							sub args_sig {
2062	24			24	0	59	my $grammar = $_[0];
2063	24					53	my $str = $_[1];
2064	24					45	my $pos = $_[2];
2065	24					30	(my $MATCH);
2066	24					170	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
2067	24					53	(($MATCH)->{bool} = ((do {
2068	24					97	((my $pos1) = $MATCH->to());
2069	24					41	(do {
2070							((((do {
2071	24					82	((my $m2) = $grammar->var_invocant($str, $MATCH->to()));
2072	24	50				168	if ($m2) {
2073	24					113	(($MATCH)->{to} = $m2->to());
2074	24					61	($MATCH->{'var_invocant'} = $m2);
2075	24					105	1
2076							}
2077							else {
2078	0					0	0
2079							}
2080							}) && (do {
2081	24					101	((my $m2) = $grammar->opt_ws($str, $MATCH->to()));
2082	24	50				150	if ($m2) {
2083	24					91	(($MATCH)->{to} = $m2->to());
2084	24					136	1
2085							}
2086							else {
2087	0					0	0
2088							}
2089							})) && (do {
2090	24					98	((my $m2) = Perlito::Expression->list_parse($str, $MATCH->to()));
2091	24	50				97	if ($m2) {
2092	24					91	(($MATCH)->{to} = $m2->to());
2093	24					67	($MATCH->{'Perlito::Expression.list_parse'} = $m2);
2094	24					125	1
2095							}
2096							else {
2097	0					0	0
2098							}
2099	24	50	50			43	})) && (((do {
			33
			33
2100	24					58	($MATCH->{capture} = (Sig->new(('invocant' => ${$MATCH->{'var_invocant'}}), ('positional' => Perlito::Expression::expand_list((${$MATCH->{'Perlito::Expression.list_parse'}})->{'exp'})), ('named' => do {
	24					89
	24					87
2101	24					503	(my $Hash_a = bless {}, 'HASH');
2102	24					184	$Hash_a
2103							}))))
2104							}) \|\| 1)))
2105							})
2106							})));
2107	24					116	$MATCH
2108							};
2109							sub method_sig {
2110	24			24	0	63	my $grammar = $_[0];
2111	24					47	my $str = $_[1];
2112	24					42	my $pos = $_[2];
2113	24					39	(my $MATCH);
2114	24					122	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
2115	24					44	(($MATCH)->{bool} = ((do {
2116	24					94	((my $pos1) = $MATCH->to());
2117							((do {
2118							(((((((do {
2119	24					91	((my $m2) = $grammar->opt_ws($str, $MATCH->to()));
2120	24	50				75	if ($m2) {
2121	24					92	(($MATCH)->{to} = $m2->to());
2122	24					180	1
2123							}
2124							else {
2125	0					0	0
2126							}
2127							}) && ((('(' eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to())))))) && (do {
2128	24					91	((my $m2) = $grammar->opt_ws($str, $MATCH->to()));
2129	24	50				75	if ($m2) {
2130	24					94	(($MATCH)->{to} = $m2->to());
2131	24					175	1
2132							}
2133							else {
2134	0					0	0
2135							}
2136							})) && (do {
2137	24					94	((my $m2) = $grammar->args_sig($str, $MATCH->to()));
2138	24	50				80	if ($m2) {
2139	24					98	(($MATCH)->{to} = $m2->to());
2140	24					63	($MATCH->{'args_sig'} = $m2);
2141	24					120	1
2142							}
2143							else {
2144	0					0	0
2145							}
2146							})) && (do {
2147	24					93	((my $m2) = $grammar->opt_ws($str, $MATCH->to()));
2148	24	50				77	if ($m2) {
2149	24					115	(($MATCH)->{to} = $m2->to());
2150	24					236	1
2151							}
2152							else {
2153	0					0	0
2154							}
2155	24	50	50			47	})) && (((')' eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to())))))) && (((do {
			33
			33
			33
			33
			33
			33
			33
2156	24					35	($MATCH->{capture} = (${$MATCH->{'args_sig'}}))
	24					81
2157							}) \|\| 1)))
2158	24	50				41	}) \|\| (do {
2159	0					0	(($MATCH)->{to} = $pos1);
2160	0	0				0	((((do {
2161							($MATCH->{capture} = (Sig->new(('invocant' => Var->new(('sigil' => chr(36)), ('twigil' => ''), ('name' => 'self'))), ('positional' => do {
2162	0					0	(my $List_a = bless [], 'ARRAY');
2163	0					0	(my $List_v = bless [], 'ARRAY');
2164	0					0	$List_a
2165	0					0	}), ('named' => do {
2166	0					0	(my $Hash_a = bless {}, 'HASH');
2167	0					0	$Hash_a
2168							}))))
2169							}) \|\| 1)))
2170							}))
2171							})));
2172	24					102	$MATCH
2173							};
2174							sub method_def {
2175	12			12	0	29	my $grammar = $_[0];
2176	12					223	my $str = $_[1];
2177	12					24	my $pos = $_[2];
2178	12					20	(my $MATCH);
2179	12					62	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
2180	12					26	(($MATCH)->{bool} = ((do {
2181	12					203	((my $pos1) = $MATCH->to());
2182	12					21	(do {
2183							((((((((((do {
2184	12					51	((my $m2) = $grammar->opt_name($str, $MATCH->to()));
2185	12	50				43	if ($m2) {
2186	12					47	(($MATCH)->{to} = $m2->to());
2187	12					39	($MATCH->{'opt_name'} = $m2);
2188	12					83	1
2189							}
2190							else {
2191	0					0	0
2192							}
2193							}) && (do {
2194	12					51	((my $m2) = $grammar->opt_ws($str, $MATCH->to()));
2195	12	50				38	if ($m2) {
2196	12					53	(($MATCH)->{to} = $m2->to());
2197	12					88	1
2198							}
2199							else {
2200	0					0	0
2201							}
2202							})) && (do {
2203	12					48	((my $m2) = $grammar->method_sig($str, $MATCH->to()));
2204	12	50				38	if ($m2) {
2205	12					44	(($MATCH)->{to} = $m2->to());
2206	12					40	($MATCH->{'method_sig'} = $m2);
2207	12					56	1
2208							}
2209							else {
2210	0					0	0
2211							}
2212							})) && (do {
2213	12					46	((my $m2) = $grammar->opt_ws($str, $MATCH->to()));
2214	12	50				37	if ($m2) {
2215	12					48	(($MATCH)->{to} = $m2->to());
2216	12					102	1
2217							}
2218							else {
2219	0					0	0
2220							}
2221							})) && (((chr(123) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to())))))) && (do {
2222	12					42	((my $m2) = $grammar->opt_ws($str, $MATCH->to()));
2223	12	50				55	if ($m2) {
2224	12					45	(($MATCH)->{to} = $m2->to());
2225	12					72	1
2226							}
2227							else {
2228	0					0	0
2229							}
2230							})) && (do {
2231	12					53	((my $m2) = $grammar->exp_stmts($str, $MATCH->to()));
2232	12	50				42	if ($m2) {
2233	12					53	(($MATCH)->{to} = $m2->to());
2234	12					43	($MATCH->{'exp_stmts'} = $m2);
2235	12					68	1
2236							}
2237							else {
2238	0					0	0
2239							}
2240							})) && (do {
2241	12					67	((my $m2) = $grammar->opt_ws($str, $MATCH->to()));
2242	12	50				42	if ($m2) {
2243	12					47	(($MATCH)->{to} = $m2->to());
2244	12					80	1
2245							}
2246							else {
2247	0					0	0
2248							}
2249							})) && (do {
2250	12					48	((my $pos1) = $MATCH->to());
2251							((do {
2252	12	50				62	((chr(125) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))
2253	12	50				27	}) \|\| (do {
2254	0					0	(($MATCH)->{to} = $pos1);
2255	0	0				0	((((do {
2256	0					0	die('Syntax Error in method ' . chr(39) . '.', ${$MATCH->{'name'}}, chr(39) . ' near pos' . chr(61), $MATCH->to())
	0					0
2257							}) \|\| 1)))
2258							}))
2259	12	50	50			19	})) && (((do {
			33
			33
			33
			33
			33
			33
			33
			33
			33
2260	12					30	($MATCH->{capture} = (Method->new(('name' => ${$MATCH->{'opt_name'}}), ('sig' => ${$MATCH->{'method_sig'}}), ('block' => ${$MATCH->{'exp_stmts'}}))))
	12					56
	12					60
	12					43
2261							}) \|\| 1)))
2262							})
2263							})));
2264	12					87	$MATCH
2265							};
2266							sub sub_def {
2267	12			12	0	22	my $grammar = $_[0];
2268	12					24	my $str = $_[1];
2269	12					20	my $pos = $_[2];
2270	12					27	(my $MATCH);
2271	12					61	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
2272	12					25	(($MATCH)->{bool} = ((do {
2273	12					40	((my $pos1) = $MATCH->to());
2274	12					21	(do {
2275							((((((((((do {
2276	12					46	((my $m2) = $grammar->opt_name($str, $MATCH->to()));
2277	12	50				35	if ($m2) {
2278	12					42	(($MATCH)->{to} = $m2->to());
2279	12					31	($MATCH->{'opt_name'} = $m2);
2280	12					53	1
2281							}
2282							else {
2283	0					0	0
2284							}
2285							}) && (do {
2286	12					41	((my $m2) = $grammar->opt_ws($str, $MATCH->to()));
2287	12	50				38	if ($m2) {
2288	12					45	(($MATCH)->{to} = $m2->to());
2289	12					63	1
2290							}
2291							else {
2292	0					0	0
2293							}
2294							})) && (do {
2295	12					39	((my $m2) = $grammar->method_sig($str, $MATCH->to()));
2296	12	50				38	if ($m2) {
2297	12					68	(($MATCH)->{to} = $m2->to());
2298	12					29	($MATCH->{'method_sig'} = $m2);
2299	12					49	1
2300							}
2301							else {
2302	0					0	0
2303							}
2304							})) && (do {
2305	12					39	((my $m2) = $grammar->opt_ws($str, $MATCH->to()));
2306	12	50				33	if ($m2) {
2307	12					42	(($MATCH)->{to} = $m2->to());
2308	12					113	1
2309							}
2310							else {
2311	0					0	0
2312							}
2313							})) && (((chr(123) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to())))))) && (do {
2314	12					40	((my $m2) = $grammar->opt_ws($str, $MATCH->to()));
2315	12	50				38	if ($m2) {
2316	12					44	(($MATCH)->{to} = $m2->to());
2317	12					65	1
2318							}
2319							else {
2320	0					0	0
2321							}
2322							})) && (do {
2323	12					47	((my $m2) = $grammar->exp_stmts($str, $MATCH->to()));
2324	12	50				37	if ($m2) {
2325	12					46	(($MATCH)->{to} = $m2->to());
2326	12					38	($MATCH->{'exp_stmts'} = $m2);
2327	12					57	1
2328							}
2329							else {
2330	0					0	0
2331							}
2332							})) && (do {
2333	12					44	((my $m2) = $grammar->opt_ws($str, $MATCH->to()));
2334	12	50				38	if ($m2) {
2335	12					48	(($MATCH)->{to} = $m2->to());
2336	12					79	1
2337							}
2338							else {
2339	0					0	0
2340							}
2341							})) && (do {
2342	12					48	((my $pos1) = $MATCH->to());
2343							((do {
2344	12	50				46	((chr(125) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to()))))
2345	12	50				18	}) \|\| (do {
2346	0					0	(($MATCH)->{to} = $pos1);
2347	0	0				0	((((do {
2348	0					0	die('Syntax Error in sub ' . chr(39), ${$MATCH->{'name'}}, chr(39))
	0					0
2349							}) \|\| 1)))
2350							}))
2351	12	50	50			17	})) && (((do {
			33
			33
			33
			33
			33
			33
			33
			33
			33
2352	12					43	($MATCH->{capture} = (Sub->new(('name' => ${$MATCH->{'opt_name'}}), ('sig' => ${$MATCH->{'method_sig'}}), ('block' => ${$MATCH->{'exp_stmts'}}))))
	12					52
	12					55
	12					37
2353							}) \|\| 1)))
2354							})
2355							})));
2356	12					84	$MATCH
2357							};
2358							sub token {
2359	4			4	0	10	my $grammar = $_[0];
2360	4					5	my $str = $_[1];
2361	4					10	my $pos = $_[2];
2362	4					5	(my $MATCH);
2363	4					28	($MATCH = Perlito::Match->new(('str' => $str), ('from' => $pos), ('to' => $pos), ('bool' => 1)));
2364	4					7	(($MATCH)->{bool} = ((do {
2365	4					14	((my $pos1) = $MATCH->to());
2366	4					6	(do {
2367							((((((do {
2368	4					14	((my $m2) = $grammar->opt_name($str, $MATCH->to()));
2369	4	50				13	if ($m2) {
2370	4					17	(($MATCH)->{to} = $m2->to());
2371	4					11	($MATCH->{'opt_name'} = $m2);
2372	4					35	1
2373							}
2374							else {
2375	0					0	0
2376							}
2377							}) && (do {
2378	4					16	((my $m2) = $grammar->opt_ws($str, $MATCH->to()));
2379	4	50				14	if ($m2) {
2380	4					37	(($MATCH)->{to} = $m2->to());
2381	4					42	1
2382							}
2383							else {
2384	0					0	0
2385							}
2386							})) && (((chr(123) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to())))))) && (do {
2387	4					19	((my $m2) = Perlito::Grammar::Regex->rule($str, $MATCH->to()));
2388	4	50				15	if ($m2) {
2389	4					16	(($MATCH)->{to} = $m2->to());
2390	4					16	($MATCH->{'Perlito::Grammar::Regex.rule'} = $m2);
2391	4					28	1
2392							}
2393							else {
2394	0					0	0
2395							}
2396	4	50	50			8	})) && (((chr(125) eq substr($str, $MATCH->to(), 1)) && ((($MATCH)->{to} = (1 + $MATCH->to())))))) && (((do {
			33
			33
			33
			33
			33
			33
2397	4					19	((my $source) = ($MATCH->{'opt_name'} . ' ( ' . chr(36) . 'grammar: ' . chr(36) . 'str, ' . chr(36) . 'pos ) ' . chr(123) . ' ' . 'my ' . chr(36) . 'MATCH' . chr(59) . ' ' . chr(36) . 'MATCH ' . chr(61) . ' Perlito::Match.new( str ' . chr(61) . '> ' . chr(36) . 'str, from ' . chr(61) . '> ' . chr(36) . 'pos, to ' . chr(61) . '> ' . chr(36) . 'pos, bool ' . chr(61) . '> 1 )' . chr(59) . ' ' . chr(36) . 'MATCH.bool ' . chr(61) . ' ( ' . (${$MATCH->{'Perlito::Grammar::Regex.rule'}})->emit_perl6() . ')' . chr(59) . ' ' . chr(36) . 'MATCH ' . chr(125)));
	4					16
2398	4					32	((my $ast) = Perlito::Grammar->method_def($source, 0));
2399	4					10	($MATCH->{capture} = (${$ast}))
	4					16
2400							}) \|\| 1)))
2401							})
2402							})));
2403	4					184	$MATCH
2404							}
2405							}
2406
2407
2408							}
2409
2410							1;