File Coverage

blib/lib/RPerl/Grammar.pm
Criterion Covered Total %
statement 9 13 69.2
branch 4 12 33.3
condition n/a
subroutine 3 4 75.0
pod 0 2 0.0
total 16 31 51.6


line stmt bran cond sub pod time code
1             ########################################################################################
2             #
3             # This file was generated using Parse::Eyapp version 1.21.
4             #
5             # Copyright © 2006, 2007, 2008, 2009, 2010, 2011, 2012 Casiano Rodriguez-Leon.
6             # Copyright © 2017 William N. Braswell, Jr.
7             # All Rights Reserved.
8             #
9             # Parse::Yapp is Copyright © 1998, 1999, 2000, 2001, Francois Desarmenien.
10             # Parse::Yapp is Copyright © 2017 William N. Braswell, Jr.
11             # All Rights Reserved.
12             #
13             # Don't edit this file, use source file 'lib/RPerl/Grammar.eyp' instead.
14             #
15             # ANY CHANGE MADE HERE WILL BE LOST !
16             #
17             ########################################################################################
18             package RPerl::Grammar;
19 3     3   19 use strict;
  3         7  
  3         207  
20              
21             push @RPerl::Grammar::ISA, 'Parse::Eyapp::Driver';
22              
23              
24              
25              
26             BEGIN {
27             # This strange way to load the modules is to guarantee compatibility when
28             # using several standalone and non-standalone Eyapp parsers
29              
30 3 50   3   1160 require Parse::Eyapp::Driver unless Parse::Eyapp::Driver->can('YYParse');
31 3 50       24780 require Parse::Eyapp::Node unless Parse::Eyapp::Node->can('hnew');
32             }
33            
34              
35 0 0   0 0 0 sub unexpendedInput { defined($_) ? substr($_, (defined(pos $_) ? pos $_ : 0)) : '' }
    0          
36              
37             #line 5 "lib/RPerl/Grammar.eyp"
38              
39             # [[[ HEADER ]]]
40             use strict;
41             use warnings;
42             our $VERSION = 0.009_000;
43              
44             use Carp;
45             use rperlrules; # affirmative, it totally does
46              
47              
48             # Default lexical analyzer
49             our $LEX = sub {
50             my $self = shift;
51             my $pos;
52              
53             for (${$self->input}) {
54            
55              
56             /\G((?:\s*(?:[#][^#!].*)?\s*)*|\s)/gc and $self->tokenline($1 =~ tr{\n}{});
57              
58             m{\G(our\ hashref\ \$properties|\#\#\ no\ critic\ qw\(|use\ parent\ qw\(|use\ warnings\;|\$RETURN_TYPE|use\ constant|use\ strict\;|package|foreach|\$TYPED_|while|\@ARG\;|undef|elsif|else|for|\%\{|\@\{|if|\)|\]|\}|\;)}gc and return ($1, $1);
59              
60             /\G(^#!\/(?:\w+\/)*perl)/gc and return ('SHEBANG', $1);
61             /\G(\s*use\s+RPerl\s*;\s*)/gc and return ('USE_RPERL', $1);
62             /\G(\s*use\s+RPerl::AfterSubclass\s*;\s*)/gc and return ('USE_RPERL_AFTER', $1);
63             /\G(\s*use\s+RPerl::Exporter\s+qw\(\s*import\s*\)\s*;\s*)/gc and return ('USE_EXPORTER', $1);
64             /\G(use\s+)/gc and return ('USE', $1);
65             /\G(\s*our\s+\@EXPORT\s+\=\s*)/gc and return ('OUR_EXPORT', $1);
66             /\G(\s*our\s+\@EXPORT_OK\s+\=\s*)/gc and return ('OUR_EXPORT_OK', $1);
67             /\G(our\s+)/gc and return ('OUR', $1);
68             /\G\$VERSION\ =\ (\d\d?\.\d{3}\_\d{3});/gc and return ('VERSION_NUMBER_ASSIGN', $1);
69             /\G(sub)\s+/gc and return ('SUB', $1);
70             /\G(my)/gc and return ('MY', $1);
71             /\G([+-]?(((\d{1,2}_)?(\d{3}_)*\d{3})|\d{1,2})(\.((\d{3}(_\d{3})*(_\d{1,2})?)|\d{1,2}))?(e[+-]?\d+)?)/gc and return ('LITERAL_NUMBER', $1);
72             /\G(('([^'\\]+|(?:\\\\)+)+')|("((\\n)|(\\t)|[^"\@\$\\])*((\\n)|(\\t))+((\\n)|(\\t)|[^"\@\$\\])*")|(q\{([^}\\]+|(?:\\\\)+)*\}))/gc and return ('LITERAL_STRING', $1);
73             /\G(\$self)/gc and return ('SELF', $1);
74             /\G(\$(?:[a-zA-Z]\w*)?[a-z]\w*(::[a-zA-Z]\w*)*)/gc and return ('VARIABLE_SYMBOL', $1);
75             /\G(\<\$[A-Z][A-Z0-9_]*\>)/gc and return ('FHREF_SYMBOL_IN', $1);
76             /\G(\{\$[A-Z][A-Z0-9_]*\})/gc and return ('FHREF_SYMBOL_BRACES', $1);
77             /\G(\$[A-Z][A-Z0-9_]*)/gc and return ('FHREF_SYMBOL', $1);
78             /\G(integer|unsigned_integer)\s+/gc and return ('TYPE_INTEGER', $1);
79             /\G(filehandleref\s+)/gc and return ('TYPE_FHREF', $1);
80             /\G((?:[a-zA-Z]\w*)+(?:::[a-zA-Z]\w*)*::method)/gc and return ('TYPE_METHOD', $1);
81             /\G((?:[a-zA-Z]\w*)(?:::[a-zA-Z]\w*)*(?:::[A-Z0-9_]*)\(\))/gc and return ('CONSTANT_CALL_SCOPED', $1);
82             /\G((?:[a-zA-Z]\w*)?(?:::[a-zA-Z]\w*)+)/gc and return ('WORD_SCOPED', $1);
83             /\G(\{\*STDOUT\}|\{\*STDERR\})/gc and return ('STDOUT_STDERR', $1);
84             /\G(<STDIN>)/gc and return ('STDIN', $1);
85             /\G(\@ARGV)/gc and return ('ARGV', $1);
86             /\G(\%ENV)/gc and return ('ENV', $1);
87             /\G(or|xor)\s/gc and return ('OP24_LOGICAL_OR_XOR', $1);
88             /\G(and)\s/gc and return ('OP23_LOGICAL_AND', $1);
89             /\G(not\()\s/gc and return ('OP22_LOGICAL_NEG_LPAREN', $1);
90             /\G(not)\s/gc and return ('OP22_LOGICAL_NEG', $1);
91             /\G(,)/gc and return ('OP21_LIST_COMMA', $1);
92             /\G(=>)/gc and return ('OP20_HASH_FATARROW', $1);
93             /\G(next;|last;)/gc and return ('OP19_LOOP_CONTROL_SCOLON', $1);
94             /\G(next|last|redo)\s/gc and return ('OP19_LOOP_CONTROL', $1);
95             /\G(\?)/gc and return ('OP18_TERNARY', $1);
96             /\G(\.\.)/gc and return ('OP17_LIST_RANGE', $1);
97             /\G(\|\|)/gc and return ('OP16_LOGICAL_OR', $1);
98             /\G(&&)/gc and return ('OP15_LOGICAL_AND', $1);
99             /\G(\||\^)/gc and return ('OP14_BITWISE_OR_XOR', $1);
100             /\G(&)/gc and return ('OP13_BITWISE_AND', $1);
101             /\G(==|!=|<=>|eq|ne|cmp)\s/gc and return ('OP12_COMPARE_EQ_NE', $1);
102             /\G(<<|>>)/gc and return ('OP09_BITWISE_SHIFT', $1);
103             /\G(-A;|-B;|-C;|-M;|-O;|-R;|-S;|-T;|-W;|-X;|-b;|-c;|-d;|-e;|-f;|-g;|-k;|-l;|-o;|-p;|-r;|-s;|-t;|-u;|-w;|-x;|-z;|alarm;|caller;|chdir;|chroot;|cos;|defined;|delete;|do;|eval;|exists;|gethostbyname;|getnetbyname;|getpgrp;|getprotobyname;|glob;|gmtime;|goto;|hex;|int;|lc;|lcfirst;|length;|localtime;|lock;|log;|lstat;|oct;|ord;|quotemeta;|rand;|readlink;|ref;|require;|rmdir;|scalar;|sin;|sleep;|sqrt;|srand;|stat;|uc;|ucfirst;|umask;)/gc and return ('OP10_NAMED_UNARY_SCOLON', $1);
104             /\G(-A\s|-B\s|-C\s|-M\s|-O\s|-R\s|-S\s|-T\s|-W\s|-X\s|-b\s|-c\s|-d\s|-e\s|-f\s|-g\s|-k\s|-l\s|-o\s|-p\s|-r\s|-s\s|-t\s|-u\s|-w\s|-x\s|-z\s|alarm\s|caller\s|chdir\s|chroot\s|cos\s|defined\s|delete\s|do\s|eval\s|exists\s|gethostbyname\s|getnetbyname\s|getpgrp\s|getprotobyname\s|glob\s|gmtime\s|goto\s|hex\s|int\s|lc\s|lcfirst\s|length\s|localtime\s|lock\s|log\s|lstat\s|oct\s|ord\s|quotemeta\s|rand\s|readlink\s|ref\s|require\s|rmdir\s|scalar\s|sin\s|sleep\s|sqrt\s|srand\s|stat\s|uc\s|ucfirst\s|umask\s)/gc and return ('OP10_NAMED_UNARY', $1);
105             /\G(\+=|-=|\*=|\/=|\.=)/gc and return ('OP19_VARIABLE_ASSIGN_BY', $1);
106             /\G(\.)/gc and return ('OP08_STRING_CAT', $1);
107             /\G(\+\+|--)/gc and return ('OP03_MATH_INC_DEC', $1);
108             /\G(\*\*)/gc and return ('OP04_MATH_POW', $1);
109             /\G(\*|\/|\%|sse_mul|sse_div)/gc and return ('OP07_MATH_MULT_DIV_MOD', $1);
110             /\G(x)\s/gc and return ('OP07_STRING_REPEAT', $1);
111             /\G([ms]\/.*(?:\/.*)?\/[a-z]*)/gc and return ('OP06_REGEX_PATTERN', $1);
112             /\G(=\~|!\~)/gc and return ('OP06_REGEX_BIND', $1);
113             /\G(!)/gc and return ('OP05_LOGICAL_NEG', $1);
114             /\G(\~\()/gc and return ('OP05_BITWISE_NEG_LPAREN', $1);
115             /\G(->\{)/gc and return ('OP02_HASH_THINARROW', $1);
116             /\G(->\[)/gc and return ('OP02_ARRAY_THINARROW', $1);
117             /\G(->new\()/gc and return ('OP02_METHOD_THINARROW_NEW', $1);
118             /\G(->[a-zA-Z]\w*)/gc and return ('OP02_METHOD_THINARROW', $1);
119             /\G(-\()/gc and return ('OP05_MATH_NEG_LPAREN', $1);
120             /\G(\+|-\s|sse_add|sse_sub)/gc and return ('OP08_MATH_ADD_SUB', $1);
121             /\G(<=|>=|<|>|le|ge|lt|gt)\s/gc and return ('OP11_COMPARE_LT_GT', $1);
122             /\G(=)/gc and return ('OP19_VARIABLE_ASSIGN', $1);
123             /\G(print|printf)\s/gc and return ('OP01_PRINT', $1);
124             /\G(croak;|die;|exit;|return;)/gc and return ('OP01_NAMED_VOID_SCOLON', $1);
125             /\G(croak\(|exit\(|return\()/gc and return ('OP01_NAMED_VOID_LPAREN', $1);
126             /\G(croak|die|exit|return)\s/gc and return ('OP01_NAMED_VOID', $1);
127             /\G(qw\([^()]*\))/gc and return ('OP01_QW', $1);
128             /\G(open)\s/gc and return ('OP01_OPEN', $1);
129             /\G(close)\s/gc and return ('OP01_CLOSE', $1);
130             /\G(abs;|accept;|atan2;|bind;|binmode;|bless;|break;|chmod;|chomp;|chop;|chown;|chr;|closedir;|connect;|continue;|crypt;|dbmclose;|dbmopen;|default;|dump;|each;|endgrent;|endhostent;|endnetent;|endprotoent;|endpwent;|endservent;|eof;|evalbytes;|exec;|exp;|fc;|fcntl;|fileno;|flock;|fork;|format;|formline;|getc;|getgrent;|getgrgid;|getgrnam;|gethostbyaddr;|gethostent;|getlogin;|getnetbyaddr;|getnetent;|getpeername;|getppid;|getpriority;|getprotobynumber;|getprotoent;|getpwent;|getpwnam;|getpwuid;|getservbyname;|getservbyport;|getservent;|getsockname;|getsockopt;|given;|grep;|index;|ioctl;|join;|keys;|kill;|link;|listen;|local;|m;|map;|mkdir;|msgctl;|msgget;|msgrcv;|msgsnd;|opendir;|pack;|pipe;|pop;|pos;|prototype;|push;|q;|qq;|qr;|qx;|read;|readdir;|readline;|readpipe;|recv;|rename;|reset;|reverse;|rewinddir;|rindex;|s;|say;|seek;|seekdir;|select;|semctl;|semget;|semop;|send;|setgrent;|sethostent;|setnetent;|setpgrp;|setpriority;|setprotoent;|setpwent;|setservent;|setsockopt;|shift;|shmctl;|shmget;|shmread;|shmwrite;|shutdown;|socket;|socketpair;|sort;|splice;|split;|sprintf;|state;|study;|substr;|symlink;|syscall;|sysopen;|sysread;|sysseek;|system;|syswrite;|tell;|telldir;|tie;|tied;|time;|times;|tr;|truncate;|unless;|unlink;|unpack;|unshift;|untie;|until;|utime;|values;|vec;|wait;|waitpid;|wantarray;|warn;|when;|write;|y;)/gc and return ('OP01_NAMED_SCOLON', $1);
131             /\G(abs\s|accept\s|atan2\s|bind\s|binmode\s|bless\s|break\s|chmod\s|chomp\s|chop\s|chown\s|chr\s|closedir\s|connect\s|continue\s|crypt\s|dbmclose\s|dbmopen\s|default\s|dump\s|each\s|endgrent\s|endhostent\s|endnetent\s|endprotoent\s|endpwent\s|endservent\s|eof\s|evalbytes\s|exec\s|exp\s|fc\s|fcntl\s|fileno\s|flock\s|fork\s|format\s|formline\s|getc\s|getgrent\s|getgrgid\s|getgrnam\s|gethostbyaddr\s|gethostent\s|getlogin\s|getnetbyaddr\s|getnetent\s|getpeername\s|getppid\s|getpriority\s|getprotobynumber\s|getprotoent\s|getpwent\s|getpwnam\s|getpwuid\s|getservbyname\s|getservbyport\s|getservent\s|getsockname\s|getsockopt\s|given\s|grep\s|index\s|ioctl\s|join\s|keys\s|kill\s|link\s|listen\s|local\s|m\s|map\s|mkdir\s|msgctl\s|msgget\s|msgrcv\s|msgsnd\s|opendir\s|pack\s|pipe\s|pop\s|pos\s|prototype\s|push\s|q\s|qq\s|qr\s|qx\s|read\s|readdir\s|readline\s|readpipe\s|recv\s|rename\s|reset\s|reverse\s|rewinddir\s|rindex\s|s\s|say\s|seek\s|seekdir\s|select\s|semctl\s|semget\s|semop\s|send\s|setgrent\s|sethostent\s|setnetent\s|setpgrp\s|setpriority\s|setprotoent\s|setpwent\s|setservent\s|setsockopt\s|shift\s|shmctl\s|shmget\s|shmread\s|shmwrite\s|shutdown\s|socket\s|socketpair\s|sort\s|splice\s|split\s|sprintf\s|state\s|study\s|substr\s|symlink\s|syscall\s|sysopen\s|sysread\s|sysseek\s|system\s|syswrite\s|tell\s|telldir\s|tie\s|tied\s|time\s|times\s|tr\s|truncate\s|unless\s|unlink\s|unpack\s|unshift\s|untie\s|until\s|utime\s|values\s|vec\s|wait\s|waitpid\s|wantarray\s|warn\s|when\s|write\s|y\s)/gc and return ('OP01_NAMED', $1);
132             /\G(:)/gc and return ('COLON', $1);
133             /\G(\(\s*my)/gc and return ('LPAREN_MY', $1);
134             /\G(\()/gc and return ('LPAREN', $1);
135             /\G(\[)/gc and return ('LBRACKET', $1);
136             /\G(\{)/gc and return ('LBRACE', $1);
137             /\G([a-z]\w*|[A-Z]\w*[a-z]\w*)/gc and return ('WORD', $1);
138             /\G([A-Z][A-Z0-9_]*|[A-Z])/gc and return ('WORD_UPPERCASE', $1);
139              
140              
141             return ('', undef) if ($_ eq '') || (defined(pos($_)) && (pos($_) >= length($_)));
142             /\G\s*(\S+)/;
143             my $near = substr($1,0,10);
144              
145             return($near, $near);
146              
147             # die( "Error inside the lexical analyzer near '". $near
148             # ."'. Line: ".$self->line()
149             # .". File: '".$self->YYFilename()."'. No match found.\n");
150             }
151             }
152             ;
153              
154              
155             #line 155 lib/RPerl/Grammar.pm
156              
157             my $warnmessage =<< "EOFWARN";
158             Warning!: Did you changed the \@RPerl::Grammar::ISA variable inside the header section of the eyapp program?
159             EOFWARN
160              
161 1744     1744 0 6092 sub new {
162 1744 50       8427 my($class)=shift;
163             ref($class) and $class=ref($class);
164 1744 50       11448  
165             warn $warnmessage unless __PACKAGE__->isa('Parse::Eyapp::Driver');
166             my($self)=$class->SUPER::new(
167             yyversion => '1.21',
168             yyGRAMMAR =>
169             [#[productionNameAndLabel => lhs, [ rhs], bypass]]
170             [ '_SUPERSTART' => '$start', [ 'CompileUnit', '$end' ], 0 ],
171             [ '_PAREN' => 'PAREN-1', [ 'ModuleHeader', 'Module' ], 0 ],
172             [ '_PLUS_LIST' => 'PLUS-2', [ 'PLUS-2', 'PAREN-1' ], 0 ],
173             [ '_PLUS_LIST' => 'PLUS-2', [ 'PAREN-1' ], 0 ],
174             [ 'CompileUnit_4' => 'CompileUnit', [ 'Program' ], 0 ],
175             [ 'CompileUnit_5' => 'CompileUnit', [ 'PLUS-2' ], 0 ],
176             [ '_OPTIONAL' => 'OPTIONAL-3', [ 'Critic' ], 0 ],
177             [ '_OPTIONAL' => 'OPTIONAL-3', [ ], 0 ],
178             [ '_STAR_LIST' => 'STAR-4', [ 'STAR-4', 'Critic' ], 0 ],
179             [ '_STAR_LIST' => 'STAR-4', [ ], 0 ],
180             [ '_STAR_LIST' => 'STAR-5', [ 'STAR-5', 'Include' ], 0 ],
181             [ '_STAR_LIST' => 'STAR-5', [ ], 0 ],
182             [ '_STAR_LIST' => 'STAR-6', [ 'STAR-6', 'Constant' ], 0 ],
183             [ '_STAR_LIST' => 'STAR-6', [ ], 0 ],
184             [ '_STAR_LIST' => 'STAR-7', [ 'STAR-7', 'Subroutine' ], 0 ],
185             [ '_STAR_LIST' => 'STAR-7', [ ], 0 ],
186             [ '_PLUS_LIST' => 'PLUS-8', [ 'PLUS-8', 'Operation' ], 0 ],
187             [ '_PLUS_LIST' => 'PLUS-8', [ 'Operation' ], 0 ],
188             [ 'Program_18' => 'Program', [ 'SHEBANG', 'OPTIONAL-3', 'USE_RPERL', 'Header', 'STAR-4', 'STAR-5', 'STAR-6', 'STAR-7', 'PLUS-8' ], 0 ],
189             [ '_OPTIONAL' => 'OPTIONAL-9', [ 'Critic' ], 0 ],
190             [ '_OPTIONAL' => 'OPTIONAL-9', [ ], 0 ],
191             [ '_OPTIONAL' => 'OPTIONAL-10', [ 'USE_RPERL' ], 0 ],
192             [ '_OPTIONAL' => 'OPTIONAL-10', [ ], 0 ],
193             [ 'ModuleHeader_23' => 'ModuleHeader', [ 'OPTIONAL-9', 'OPTIONAL-10', 'package', 'WordScoped', ';', 'Header' ], 0 ],
194             [ 'Module_24' => 'Module', [ 'Package' ], 0 ],
195             [ 'Module_25' => 'Module', [ 'Class' ], 0 ],
196             [ '_STAR_LIST' => 'STAR-11', [ 'STAR-11', 'Critic' ], 0 ],
197             [ '_STAR_LIST' => 'STAR-11', [ ], 0 ],
198             [ '_OPTIONAL' => 'OPTIONAL-12', [ 'Exports' ], 0 ],
199             [ '_OPTIONAL' => 'OPTIONAL-12', [ ], 0 ],
200             [ '_STAR_LIST' => 'STAR-13', [ 'STAR-13', 'Include' ], 0 ],
201             [ '_STAR_LIST' => 'STAR-13', [ ], 0 ],
202             [ '_STAR_LIST' => 'STAR-14', [ 'STAR-14', 'Constant' ], 0 ],
203             [ '_STAR_LIST' => 'STAR-14', [ ], 0 ],
204             [ '_PLUS_LIST' => 'PLUS-15', [ 'PLUS-15', 'Subroutine' ], 0 ],
205             [ '_PLUS_LIST' => 'PLUS-15', [ 'Subroutine' ], 0 ],
206             [ 'Package_36' => 'Package', [ 'STAR-11', 'OPTIONAL-12', 'STAR-13', 'STAR-14', 'PLUS-15', 'LITERAL_NUMBER', ';' ], 0 ],
207             [ '_OPTIONAL' => 'OPTIONAL-16', [ 'USE_RPERL_AFTER' ], 0 ],
208             [ '_OPTIONAL' => 'OPTIONAL-16', [ ], 0 ],
209             [ 'Header_39' => 'Header', [ 'use strict;', 'use warnings;', 'OPTIONAL-16', 'OUR', 'VERSION_NUMBER_ASSIGN' ], 0 ],
210             [ '_PLUS_LIST' => 'PLUS-17', [ 'PLUS-17', 'WORD' ], 0 ],
211             [ '_PLUS_LIST' => 'PLUS-17', [ 'WORD' ], 0 ],
212             [ 'Critic_42' => 'Critic', [ '## no critic qw(', 'PLUS-17', ')' ], 0 ],
213             [ '_PAREN' => 'PAREN-18', [ 'OUR_EXPORT', 'OP01_QW', ';' ], 0 ],
214             [ '_OPTIONAL' => 'OPTIONAL-19', [ 'PAREN-18' ], 0 ],
215             [ '_OPTIONAL' => 'OPTIONAL-19', [ ], 0 ],
216             [ '_PAREN' => 'PAREN-20', [ 'OUR_EXPORT_OK', 'OP01_QW', ';' ], 0 ],
217             [ '_OPTIONAL' => 'OPTIONAL-21', [ 'PAREN-20' ], 0 ],
218             [ '_OPTIONAL' => 'OPTIONAL-21', [ ], 0 ],
219             [ 'Exports_49' => 'Exports', [ 'USE_EXPORTER', 'OPTIONAL-19', 'OPTIONAL-21' ], 0 ],
220             [ 'Include_50' => 'Include', [ 'USE', 'WordScoped', ';' ], 0 ],
221             [ 'Include_51' => 'Include', [ 'USE', 'WordScoped', 'OP01_QW', ';' ], 0 ],
222             [ 'Constant_52' => 'Constant', [ 'use constant', 'WORD_UPPERCASE', 'OP20_HASH_FATARROW', 'TypeInnerConstant', 'Literal', ';' ], 0 ],
223             [ '_OPTIONAL' => 'OPTIONAL-22', [ 'SubroutineArguments' ], 0 ],
224             [ '_OPTIONAL' => 'OPTIONAL-22', [ ], 0 ],
225             [ '_STAR_LIST' => 'STAR-23', [ 'STAR-23', 'Operation' ], 0 ],
226             [ '_STAR_LIST' => 'STAR-23', [ ], 0 ],
227             [ 'Subroutine_57' => 'Subroutine', [ 'SUB', 'WORD', 'LBRACE', 'LBRACE', 'MY', 'Type', '$RETURN_TYPE', '}', ';', 'OPTIONAL-22', 'STAR-23', '}' ], 0 ],
228             [ '_PAREN' => 'PAREN-24', [ 'OP21_LIST_COMMA', 'MY', 'Type', 'VARIABLE_SYMBOL' ], 0 ],
229             [ '_STAR_LIST' => 'STAR-25', [ 'STAR-25', 'PAREN-24' ], 0 ],
230             [ '_STAR_LIST' => 'STAR-25', [ ], 0 ],
231             [ 'SubroutineArguments_61' => 'SubroutineArguments', [ 'LPAREN_MY', 'Type', 'VARIABLE_SYMBOL', 'STAR-25', ')', 'OP19_VARIABLE_ASSIGN', '@ARG;' ], 0 ],
232             [ '_STAR_LIST' => 'STAR-26', [ 'STAR-26', 'Critic' ], 0 ],
233             [ '_STAR_LIST' => 'STAR-26', [ ], 0 ],
234             [ '_OPTIONAL' => 'OPTIONAL-27', [ 'Exports' ], 0 ],
235             [ '_OPTIONAL' => 'OPTIONAL-27', [ ], 0 ],
236             [ '_STAR_LIST' => 'STAR-28', [ 'STAR-28', 'Include' ], 0 ],
237             [ '_STAR_LIST' => 'STAR-28', [ ], 0 ],
238             [ '_STAR_LIST' => 'STAR-29', [ 'STAR-29', 'Constant' ], 0 ],
239             [ '_STAR_LIST' => 'STAR-29', [ ], 0 ],
240             [ '_STAR_LIST' => 'STAR-30', [ 'STAR-30', 'SubroutineOrMethod' ], 0 ],
241             [ '_STAR_LIST' => 'STAR-30', [ ], 0 ],
242             [ 'Class_72' => 'Class', [ 'use parent qw(', 'WordScoped', ')', ';', 'Include', 'STAR-26', 'OPTIONAL-27', 'STAR-28', 'STAR-29', 'Properties', 'STAR-30', 'LITERAL_NUMBER', ';' ], 0 ],
243             [ '_PAREN' => 'PAREN-31', [ 'OP21_LIST_COMMA', 'HashEntryProperties' ], 0 ],
244             [ '_STAR_LIST' => 'STAR-32', [ 'STAR-32', 'PAREN-31' ], 0 ],
245             [ '_STAR_LIST' => 'STAR-32', [ ], 0 ],
246             [ 'Properties_76' => 'Properties', [ 'our hashref $properties', 'OP19_VARIABLE_ASSIGN', 'LBRACE', 'HashEntryProperties', 'STAR-32', '}', ';' ], 0 ],
247             [ 'Properties_77' => 'Properties', [ 'our hashref $properties', 'OP19_VARIABLE_ASSIGN', 'LBRACE', '}', ';' ], 0 ],
248             [ '_OPTIONAL' => 'OPTIONAL-33', [ 'MethodArguments' ], 0 ],
249             [ '_OPTIONAL' => 'OPTIONAL-33', [ ], 0 ],
250             [ '_STAR_LIST' => 'STAR-34', [ 'STAR-34', 'Operation' ], 0 ],
251             [ '_STAR_LIST' => 'STAR-34', [ ], 0 ],
252             [ 'Method_82' => 'Method', [ 'SUB', 'WORD', 'LBRACE', 'LBRACE', 'MY', 'TYPE_METHOD', '$RETURN_TYPE', '}', ';', 'OPTIONAL-33', 'STAR-34', '}' ], 0 ],
253             [ '_PAREN' => 'PAREN-35', [ 'OP21_LIST_COMMA', 'MY', 'Type', 'VARIABLE_SYMBOL' ], 0 ],
254             [ '_STAR_LIST' => 'STAR-36', [ 'STAR-36', 'PAREN-35' ], 0 ],
255             [ '_STAR_LIST' => 'STAR-36', [ ], 0 ],
256             [ 'MethodArguments_86' => 'MethodArguments', [ 'LPAREN_MY', 'Type', 'SELF', 'STAR-36', ')', 'OP19_VARIABLE_ASSIGN', '@ARG;' ], 0 ],
257             [ 'SubroutineOrMethod_87' => 'SubroutineOrMethod', [ 'Subroutine' ], 0 ],
258             [ 'SubroutineOrMethod_88' => 'SubroutineOrMethod', [ 'Method' ], 0 ],
259             [ 'Operation_89' => 'Operation', [ 'Expression', ';' ], 0 ],
260             [ 'Operation_90' => 'Operation', [ 'OP01_NAMED_SCOLON' ], 0 ],
261             [ 'Operation_91' => 'Operation', [ 'OP10_NAMED_UNARY_SCOLON' ], 0 ],
262             [ 'Operation_92' => 'Operation', [ 'Statement' ], 0 ],
263             [ 'Operator_93' => 'Operator', [ 'LPAREN', 'OP01_PRINT', 'FHREF_SYMBOL_BRACES', 'ListElements', ')' ], 0 ],
264             [ 'Operator_94' => 'Operator', [ 'OP01_NAMED', 'SubExpression' ], 0 ],
265             [ 'Operator_95' => 'Operator', [ 'LPAREN', 'OP01_NAMED', 'ListElement', 'OP21_LIST_COMMA', 'ListElements', ')' ], 0 ],
266             [ 'Operator_96' => 'Operator', [ 'OP01_OPEN', 'MY', 'TYPE_FHREF', 'FHREF_SYMBOL', 'OP21_LIST_COMMA', 'LITERAL_STRING', 'OP21_LIST_COMMA', 'SubExpression' ], 0 ],
267             [ 'Operator_97' => 'Operator', [ 'OP01_CLOSE', 'FHREF_SYMBOL' ], 0 ],
268             [ 'Operator_98' => 'Operator', [ 'OP03_MATH_INC_DEC', 'Variable' ], 0 ],
269             [ 'Operator_99' => 'Operator', [ 'Variable', 'OP03_MATH_INC_DEC' ], 0 ],
270             [ 'Operator_100' => 'Operator', [ 'SubExpression', 'OP04_MATH_POW', 'SubExpression' ], 0 ],
271             [ 'Operator_101' => 'Operator', [ 'OP05_BITWISE_NEG_LPAREN', 'SubExpression', ')' ], 0 ],
272             [ 'Operator_102' => 'Operator', [ 'OP05_LOGICAL_NEG', 'SubExpression' ], 0 ],
273             [ 'Operator_103' => 'Operator', [ 'OP05_MATH_NEG_LPAREN', 'SubExpression', ')' ], 0 ],
274             [ 'Operator_104' => 'Operator', [ 'SubExpression', 'OP06_REGEX_BIND', 'OP06_REGEX_PATTERN' ], 0 ],
275             [ 'Operator_105' => 'Operator', [ 'SubExpression', 'OP07_STRING_REPEAT', 'SubExpression' ], 0 ],
276             [ 'Operator_106' => 'Operator', [ 'SubExpression', 'OP07_MATH_MULT_DIV_MOD', 'SubExpression' ], 0 ],
277             [ 'Operator_107' => 'Operator', [ 'SubExpression', 'OP08_MATH_ADD_SUB', 'SubExpression' ], 0 ],
278             [ 'Operator_108' => 'Operator', [ 'SubExpression', 'OP08_STRING_CAT', 'SubExpression' ], 0 ],
279             [ 'Operator_109' => 'Operator', [ 'SubExpression', 'OP09_BITWISE_SHIFT', 'SubExpression' ], 0 ],
280             [ 'Operator_110' => 'Operator', [ 'OP10_NAMED_UNARY', 'SubExpression' ], 0 ],
281             [ 'Operator_111' => 'Operator', [ 'OP10_NAMED_UNARY' ], 0 ],
282             [ 'Operator_112' => 'Operator', [ 'SubExpression', 'OP11_COMPARE_LT_GT', 'SubExpression' ], 0 ],
283             [ 'Operator_113' => 'Operator', [ 'SubExpression', 'OP12_COMPARE_EQ_NE', 'SubExpression' ], 0 ],
284             [ 'Operator_114' => 'Operator', [ 'SubExpression', 'OP13_BITWISE_AND', 'SubExpression' ], 0 ],
285             [ 'Operator_115' => 'Operator', [ 'SubExpression', 'OP14_BITWISE_OR_XOR', 'SubExpression' ], 0 ],
286             [ 'Operator_116' => 'Operator', [ 'SubExpression', 'OP15_LOGICAL_AND', 'SubExpression' ], 0 ],
287             [ 'Operator_117' => 'Operator', [ 'SubExpression', 'OP16_LOGICAL_OR', 'SubExpression' ], 0 ],
288             [ 'Operator_118' => 'Operator', [ 'SubExpression', 'OP17_LIST_RANGE', 'SubExpression' ], 0 ],
289             [ 'Operator_119' => 'Operator', [ 'SubExpression', 'OP18_TERNARY', 'VariableOrLiteral', 'COLON', 'VariableOrLiteral' ], 0 ],
290             [ 'Operator_120' => 'Operator', [ 'OP22_LOGICAL_NEG_LPAREN', 'SubExpression', ')' ], 0 ],
291             [ 'Operator_121' => 'Operator', [ 'OP22_LOGICAL_NEG', 'SubExpression' ], 0 ],
292             [ 'Operator_122' => 'Operator', [ 'SubExpression', 'OP23_LOGICAL_AND', 'SubExpression' ], 0 ],
293             [ 'Operator_123' => 'Operator', [ 'SubExpression', 'OP24_LOGICAL_OR_XOR', 'SubExpression' ], 0 ],
294             [ '_PAREN' => 'PAREN-37', [ 'STDOUT_STDERR' ], 0 ],
295             [ '_OPTIONAL' => 'OPTIONAL-38', [ 'PAREN-37' ], 0 ],
296             [ '_OPTIONAL' => 'OPTIONAL-38', [ ], 0 ],
297             [ '_OPTIONAL' => 'OPTIONAL-39', [ 'ListElements' ], 0 ],
298             [ '_OPTIONAL' => 'OPTIONAL-39', [ ], 0 ],
299             [ 'OperatorVoid_129' => 'OperatorVoid', [ 'OP01_PRINT', 'OPTIONAL-38', 'ListElements', ';' ], 0 ],
300             [ 'OperatorVoid_130' => 'OperatorVoid', [ 'OP01_PRINT', 'FHREF_SYMBOL_BRACES', 'ListElements', ';' ], 0 ],
301             [ 'OperatorVoid_131' => 'OperatorVoid', [ 'OP01_NAMED_VOID_SCOLON' ], 0 ],
302             [ 'OperatorVoid_132' => 'OperatorVoid', [ 'OP01_NAMED_VOID_LPAREN', 'OPTIONAL-39', ')', ';' ], 0 ],
303             [ 'OperatorVoid_133' => 'OperatorVoid', [ 'OP01_NAMED_VOID', 'ListElements', ';' ], 0 ],
304             [ 'OperatorVoid_134' => 'OperatorVoid', [ 'OP01_NAMED', 'ListElement', 'OP21_LIST_COMMA', 'ListElements', ';' ], 0 ],
305             [ 'OperatorVoid_135' => 'OperatorVoid', [ 'OP19_LOOP_CONTROL_SCOLON' ], 0 ],
306             [ 'OperatorVoid_136' => 'OperatorVoid', [ 'OP19_LOOP_CONTROL', 'LoopLabel', ';' ], 0 ],
307             [ '_OPTIONAL' => 'OPTIONAL-40', [ 'ListElements' ], 0 ],
308             [ '_OPTIONAL' => 'OPTIONAL-40', [ ], 0 ],
309             [ '_OPTIONAL' => 'OPTIONAL-41', [ 'ListElements' ], 0 ],
310             [ '_OPTIONAL' => 'OPTIONAL-41', [ ], 0 ],
311             [ '_OPTIONAL' => 'OPTIONAL-42', [ 'HashReference' ], 0 ],
312             [ '_OPTIONAL' => 'OPTIONAL-42', [ ], 0 ],
313             [ 'Expression_143' => 'Expression', [ 'Operator' ], 0 ],
314             [ 'Expression_144' => 'Expression', [ 'WORD_UPPERCASE', 'LPAREN', ')' ], 0 ],
315             [ 'Expression_145' => 'Expression', [ 'CONSTANT_CALL_SCOPED' ], 0 ],
316             [ 'Expression_146' => 'Expression', [ 'WordScoped', 'LPAREN', 'OPTIONAL-40', ')' ], 0 ],
317             [ 'Expression_147' => 'Expression', [ 'Variable', 'OP02_METHOD_THINARROW', 'LPAREN', 'OPTIONAL-41', ')' ], 0 ],
318             [ 'Expression_148' => 'Expression', [ 'WordScoped', 'OP02_METHOD_THINARROW_NEW', 'OPTIONAL-42', ')' ], 0 ],
319             [ 'SubExpression_149' => 'SubExpression', [ 'Expression' ], 0 ],
320             [ 'SubExpression_150' => 'SubExpression', [ 'undef' ], 0 ],
321             [ 'SubExpression_151' => 'SubExpression', [ 'Literal' ], 0 ],
322             [ 'SubExpression_152' => 'SubExpression', [ 'Variable' ], 0 ],
323             [ 'SubExpression_153' => 'SubExpression', [ 'ArrayReference' ], 0 ],
324             [ 'SubExpression_154' => 'SubExpression', [ 'ArrayDereference' ], 0 ],
325             [ 'SubExpression_155' => 'SubExpression', [ 'HashReference' ], 0 ],
326             [ 'SubExpression_156' => 'SubExpression', [ 'HashDereference' ], 0 ],
327             [ 'SubExpression_157' => 'SubExpression', [ 'LPAREN', 'SubExpression', ')' ], 0 ],
328             [ 'SubExpressionOrInput_158' => 'SubExpressionOrInput', [ 'SubExpression' ], 0 ],
329             [ 'SubExpressionOrInput_159' => 'SubExpressionOrInput', [ 'FHREF_SYMBOL_IN' ], 0 ],
330             [ 'SubExpressionOrInput_160' => 'SubExpressionOrInput', [ 'STDIN' ], 0 ],
331             [ 'SubExpressionOrVarMod_161' => 'SubExpressionOrVarMod', [ 'SubExpression' ], 0 ],
332             [ 'SubExpressionOrVarMod_162' => 'SubExpressionOrVarMod', [ 'VariableModification' ], 0 ],
333             [ '_PAREN' => 'PAREN-43', [ 'LoopLabel', 'COLON' ], 0 ],
334             [ '_OPTIONAL' => 'OPTIONAL-44', [ 'PAREN-43' ], 0 ],
335             [ '_OPTIONAL' => 'OPTIONAL-44', [ ], 0 ],
336             [ 'Statement_166' => 'Statement', [ 'Conditional' ], 0 ],
337             [ 'Statement_167' => 'Statement', [ 'OPTIONAL-44', 'Loop' ], 0 ],
338             [ 'Statement_168' => 'Statement', [ 'OperatorVoid' ], 0 ],
339             [ 'Statement_169' => 'Statement', [ 'VariableDeclaration' ], 0 ],
340             [ 'Statement_170' => 'Statement', [ 'VariableModification', ';' ], 0 ],
341             [ '_PAREN' => 'PAREN-45', [ 'elsif', 'LPAREN', 'SubExpression', ')', 'CodeBlock' ], 0 ],
342             [ '_STAR_LIST' => 'STAR-46', [ 'STAR-46', 'PAREN-45' ], 0 ],
343             [ '_STAR_LIST' => 'STAR-46', [ ], 0 ],
344             [ '_PAREN' => 'PAREN-47', [ 'else', 'CodeBlock' ], 0 ],
345             [ '_OPTIONAL' => 'OPTIONAL-48', [ 'PAREN-47' ], 0 ],
346             [ '_OPTIONAL' => 'OPTIONAL-48', [ ], 0 ],
347             [ 'Conditional_177' => 'Conditional', [ 'if', 'LPAREN', 'SubExpression', ')', 'CodeBlock', 'STAR-46', 'OPTIONAL-48' ], 0 ],
348             [ 'Loop_178' => 'Loop', [ 'LoopFor' ], 0 ],
349             [ 'Loop_179' => 'Loop', [ 'LoopForEach' ], 0 ],
350             [ 'Loop_180' => 'Loop', [ 'LoopWhile' ], 0 ],
351             [ 'LoopFor_181' => 'LoopFor', [ 'for', 'MY', 'TYPE_INTEGER', 'VARIABLE_SYMBOL', 'LPAREN', 'SubExpression', 'OP17_LIST_RANGE', 'SubExpression', ')', 'CodeBlock' ], 0 ],
352             [ 'LoopFor_182' => 'LoopFor', [ 'for', 'LPAREN_MY', 'TYPE_INTEGER', 'VARIABLE_SYMBOL', 'OP19_VARIABLE_ASSIGN', 'OpNamedScolonOrSubExp', 'VARIABLE_SYMBOL', 'OP11_COMPARE_LT_GT', 'OpNamedScolonOrSubExp', 'SubExpressionOrVarMod', ')', 'CodeBlock' ], 0 ],
353             [ 'LoopForEach_183' => 'LoopForEach', [ 'foreach', 'MY', 'Type', 'VARIABLE_SYMBOL', 'LPAREN', 'ListElements', ')', 'CodeBlock' ], 0 ],
354             [ 'LoopWhile_184' => 'LoopWhile', [ 'while', 'LPAREN', 'SubExpression', ')', 'CodeBlock' ], 0 ],
355             [ 'LoopWhile_185' => 'LoopWhile', [ 'while', 'LPAREN_MY', 'Type', 'VARIABLE_SYMBOL', 'OP19_VARIABLE_ASSIGN', 'SubExpressionOrInput', ')', 'CodeBlock' ], 0 ],
356             [ '_PLUS_LIST' => 'PLUS-49', [ 'PLUS-49', 'Operation' ], 0 ],
357             [ '_PLUS_LIST' => 'PLUS-49', [ 'Operation' ], 0 ],
358             [ 'CodeBlock_188' => 'CodeBlock', [ 'LBRACE', 'PLUS-49', '}' ], 0 ],
359             [ '_STAR_LIST' => 'STAR-50', [ 'STAR-50', 'VariableRetrieval' ], 0 ],
360             [ '_STAR_LIST' => 'STAR-50', [ ], 0 ],
361             [ 'Variable_191' => 'Variable', [ 'VariableSymbolOrSelf', 'STAR-50' ], 0 ],
362             [ 'VariableRetrieval_192' => 'VariableRetrieval', [ 'OP02_ARRAY_THINARROW', 'SubExpression', ']' ], 0 ],
363             [ 'VariableRetrieval_193' => 'VariableRetrieval', [ 'OP02_HASH_THINARROW', 'SubExpression', '}' ], 0 ],
364             [ 'VariableRetrieval_194' => 'VariableRetrieval', [ 'OP02_HASH_THINARROW', 'WORD', '}' ], 0 ],
365             [ 'VariableDeclaration_195' => 'VariableDeclaration', [ 'MY', 'Type', 'VARIABLE_SYMBOL', ';' ], 0 ],
366             [ 'VariableDeclaration_196' => 'VariableDeclaration', [ 'MY', 'Type', 'VARIABLE_SYMBOL', 'OP19_VARIABLE_ASSIGN', 'OpNamedScolonOrSubExpIn' ], 0 ],
367             [ 'VariableDeclaration_197' => 'VariableDeclaration', [ 'MY', 'Type', 'VARIABLE_SYMBOL', 'OP02_ARRAY_THINARROW', 'SubExpression', ']', 'OP19_VARIABLE_ASSIGN', 'undef', ';' ], 0 ],
368             [ 'VariableDeclaration_198' => 'VariableDeclaration', [ 'MY', 'TYPE_FHREF', 'FHREF_SYMBOL', ';' ], 0 ],
369             [ 'VariableModification_199' => 'VariableModification', [ 'Variable', 'OP19_VARIABLE_ASSIGN', 'SubExpressionOrInput' ], 0 ],
370             [ 'VariableModification_200' => 'VariableModification', [ 'Variable', 'OP19_VARIABLE_ASSIGN_BY', 'SubExpression' ], 0 ],
371             [ '_PAREN' => 'PAREN-51', [ 'OP21_LIST_COMMA', 'ListElement' ], 0 ],
372             [ '_STAR_LIST' => 'STAR-52', [ 'STAR-52', 'PAREN-51' ], 0 ],
373             [ '_STAR_LIST' => 'STAR-52', [ ], 0 ],
374             [ 'ListElements_204' => 'ListElements', [ 'ListElement', 'STAR-52' ], 0 ],
375             [ 'ListElement_205' => 'ListElement', [ 'SubExpression' ], 0 ],
376             [ 'ListElement_206' => 'ListElement', [ 'TypeInner', 'SubExpression' ], 0 ],
377             [ 'ListElement_207' => 'ListElement', [ 'OP01_QW' ], 0 ],
378             [ 'ListElement_208' => 'ListElement', [ 'ARGV' ], 0 ],
379             [ '_OPTIONAL' => 'OPTIONAL-53', [ 'ListElements' ], 0 ],
380             [ '_OPTIONAL' => 'OPTIONAL-53', [ ], 0 ],
381             [ 'ArrayReference_211' => 'ArrayReference', [ 'LBRACKET', 'OPTIONAL-53', ']' ], 0 ],
382             [ '_OPTIONAL' => 'OPTIONAL-54', [ 'TypeInner' ], 0 ],
383             [ '_OPTIONAL' => 'OPTIONAL-54', [ ], 0 ],
384             [ 'ArrayDereference_214' => 'ArrayDereference', [ '@{', 'Variable', '}' ], 0 ],
385             [ 'ArrayDereference_215' => 'ArrayDereference', [ '@{', 'OPTIONAL-54', 'ArrayReference', '}' ], 0 ],
386             [ '_OPTIONAL' => 'OPTIONAL-55', [ 'TypeInner' ], 0 ],
387             [ '_OPTIONAL' => 'OPTIONAL-55', [ ], 0 ],
388             [ 'HashEntry_218' => 'HashEntry', [ 'VarOrLitOrOpStrOrWord', 'OP20_HASH_FATARROW', 'OPTIONAL-55', 'SubExpression' ], 0 ],
389             [ 'HashEntry_219' => 'HashEntry', [ 'HashDereference' ], 0 ],
390             [ 'HashEntry_220' => 'HashEntry', [ 'ENV' ], 0 ],
391             [ 'HashEntryProperties_221' => 'HashEntryProperties', [ 'OpStringOrWord', 'OP20_HASH_FATARROW', 'TypeInnerProperties' ], 0 ],
392             [ '_PAREN' => 'PAREN-56', [ 'OP21_LIST_COMMA', 'HashEntry' ], 0 ],
393             [ '_STAR_LIST' => 'STAR-57', [ 'STAR-57', 'PAREN-56' ], 0 ],
394             [ '_STAR_LIST' => 'STAR-57', [ ], 0 ],
395             [ 'HashReference_225' => 'HashReference', [ 'LBRACE', 'HashEntry', 'STAR-57', '}' ], 0 ],
396             [ 'HashReference_226' => 'HashReference', [ 'LBRACE', '}' ], 0 ],
397             [ '_OPTIONAL' => 'OPTIONAL-58', [ 'TypeInner' ], 0 ],
398             [ '_OPTIONAL' => 'OPTIONAL-58', [ ], 0 ],
399             [ 'HashDereference_229' => 'HashDereference', [ '%{', 'Variable', '}' ], 0 ],
400             [ 'HashDereference_230' => 'HashDereference', [ '%{', 'OPTIONAL-58', 'HashReference', '}' ], 0 ],
401             [ 'WordScoped_231' => 'WordScoped', [ 'WORD' ], 0 ],
402             [ 'WordScoped_232' => 'WordScoped', [ 'WORD_SCOPED' ], 0 ],
403             [ 'LoopLabel_233' => 'LoopLabel', [ 'WORD_UPPERCASE' ], 0 ],
404             [ 'Type_234' => 'Type', [ 'WORD' ], 0 ],
405             [ 'Type_235' => 'Type', [ 'WORD_SCOPED' ], 0 ],
406             [ 'Type_236' => 'Type', [ 'TYPE_INTEGER' ], 0 ],
407             [ 'TypeInner_237' => 'TypeInner', [ 'MY', 'Type', '$TYPED_', 'OpStringOrWord', 'OP19_VARIABLE_ASSIGN' ], 0 ],
408             [ 'TypeInnerProperties_238' => 'TypeInnerProperties', [ 'MY', 'Type', '$TYPED_', 'OpStringOrWord', 'OP19_VARIABLE_ASSIGN', 'SubExpression' ], 0 ],
409             [ 'TypeInnerProperties_239' => 'TypeInnerProperties', [ 'MY', 'Type', '$TYPED_', 'OpStringOrWord', 'OP02_ARRAY_THINARROW', 'SubExpression', ']', 'OP19_VARIABLE_ASSIGN', 'undef' ], 0 ],
410             [ 'TypeInnerConstant_240' => 'TypeInnerConstant', [ 'MY', 'Type', '$TYPED_', 'WORD_UPPERCASE', 'OP19_VARIABLE_ASSIGN' ], 0 ],
411             [ 'VariableOrLiteral_241' => 'VariableOrLiteral', [ 'Variable' ], 0 ],
412             [ 'VariableOrLiteral_242' => 'VariableOrLiteral', [ 'Literal' ], 0 ],
413             [ 'VarOrLitOrOpStrOrWord_243' => 'VarOrLitOrOpStrOrWord', [ 'Variable' ], 0 ],
414             [ 'VarOrLitOrOpStrOrWord_244' => 'VarOrLitOrOpStrOrWord', [ 'Literal' ], 0 ],
415             [ 'VarOrLitOrOpStrOrWord_245' => 'VarOrLitOrOpStrOrWord', [ 'OpStringOrWord' ], 0 ],
416             [ 'VariableSymbolOrSelf_246' => 'VariableSymbolOrSelf', [ 'VARIABLE_SYMBOL' ], 0 ],
417             [ 'VariableSymbolOrSelf_247' => 'VariableSymbolOrSelf', [ 'SELF' ], 0 ],
418             [ 'Literal_248' => 'Literal', [ 'LITERAL_NUMBER' ], 0 ],
419             [ 'Literal_249' => 'Literal', [ 'LITERAL_STRING' ], 0 ],
420             [ 'OpNamedScolonOrSubExp_250' => 'OpNamedScolonOrSubExp', [ 'OP01_NAMED_SCOLON' ], 0 ],
421             [ 'OpNamedScolonOrSubExp_251' => 'OpNamedScolonOrSubExp', [ 'OP10_NAMED_UNARY_SCOLON' ], 0 ],
422             [ 'OpNamedScolonOrSubExp_252' => 'OpNamedScolonOrSubExp', [ 'SubExpression', ';' ], 0 ],
423             [ 'OpNamedScolonOrSubExpIn_253' => 'OpNamedScolonOrSubExpIn', [ 'OP01_NAMED_SCOLON' ], 0 ],
424             [ 'OpNamedScolonOrSubExpIn_254' => 'OpNamedScolonOrSubExpIn', [ 'OP10_NAMED_UNARY_SCOLON' ], 0 ],
425             [ 'OpNamedScolonOrSubExpIn_255' => 'OpNamedScolonOrSubExpIn', [ 'SubExpressionOrInput', ';' ], 0 ],
426             [ 'OpStringOrWord_256' => 'OpStringOrWord', [ 'OP24_LOGICAL_OR_XOR' ], 0 ],
427             [ 'OpStringOrWord_257' => 'OpStringOrWord', [ 'OP23_LOGICAL_AND' ], 0 ],
428             [ 'OpStringOrWord_258' => 'OpStringOrWord', [ 'OP22_LOGICAL_NEG' ], 0 ],
429             [ 'OpStringOrWord_259' => 'OpStringOrWord', [ 'OP19_LOOP_CONTROL_SCOLON' ], 0 ],
430             [ 'OpStringOrWord_260' => 'OpStringOrWord', [ 'OP19_LOOP_CONTROL' ], 0 ],
431             [ 'OpStringOrWord_261' => 'OpStringOrWord', [ 'OP12_COMPARE_EQ_NE' ], 0 ],
432             [ 'OpStringOrWord_262' => 'OpStringOrWord', [ 'OP11_COMPARE_LT_GT' ], 0 ],
433             [ 'OpStringOrWord_263' => 'OpStringOrWord', [ 'OP10_NAMED_UNARY' ], 0 ],
434             [ 'OpStringOrWord_264' => 'OpStringOrWord', [ 'OP08_MATH_ADD_SUB' ], 0 ],
435             [ 'OpStringOrWord_265' => 'OpStringOrWord', [ 'OP07_MATH_MULT_DIV_MOD' ], 0 ],
436             [ 'OpStringOrWord_266' => 'OpStringOrWord', [ 'OP07_STRING_REPEAT' ], 0 ],
437             [ 'OpStringOrWord_267' => 'OpStringOrWord', [ 'OP01_NAMED' ], 0 ],
438             [ 'OpStringOrWord_268' => 'OpStringOrWord', [ 'OP01_CLOSE' ], 0 ],
439             [ 'OpStringOrWord_269' => 'OpStringOrWord', [ 'OP01_OPEN' ], 0 ],
440             [ 'OpStringOrWord_270' => 'OpStringOrWord', [ 'OP01_NAMED_VOID' ], 0 ],
441             [ 'OpStringOrWord_271' => 'OpStringOrWord', [ 'OP01_PRINT' ], 0 ],
442             [ 'OpStringOrWord_272' => 'OpStringOrWord', [ 'WORD' ], 0 ],
443             ],
444             yyLABELS =>
445             {
446             '_SUPERSTART' => 0,
447             '_PAREN' => 1,
448             '_PLUS_LIST' => 2,
449             '_PLUS_LIST' => 3,
450             'CompileUnit_4' => 4,
451             'CompileUnit_5' => 5,
452             '_OPTIONAL' => 6,
453             '_OPTIONAL' => 7,
454             '_STAR_LIST' => 8,
455             '_STAR_LIST' => 9,
456             '_STAR_LIST' => 10,
457             '_STAR_LIST' => 11,
458             '_STAR_LIST' => 12,
459             '_STAR_LIST' => 13,
460             '_STAR_LIST' => 14,
461             '_STAR_LIST' => 15,
462             '_PLUS_LIST' => 16,
463             '_PLUS_LIST' => 17,
464             'Program_18' => 18,
465             '_OPTIONAL' => 19,
466             '_OPTIONAL' => 20,
467             '_OPTIONAL' => 21,
468             '_OPTIONAL' => 22,
469             'ModuleHeader_23' => 23,
470             'Module_24' => 24,
471             'Module_25' => 25,
472             '_STAR_LIST' => 26,
473             '_STAR_LIST' => 27,
474             '_OPTIONAL' => 28,
475             '_OPTIONAL' => 29,
476             '_STAR_LIST' => 30,
477             '_STAR_LIST' => 31,
478             '_STAR_LIST' => 32,
479             '_STAR_LIST' => 33,
480             '_PLUS_LIST' => 34,
481             '_PLUS_LIST' => 35,
482             'Package_36' => 36,
483             '_OPTIONAL' => 37,
484             '_OPTIONAL' => 38,
485             'Header_39' => 39,
486             '_PLUS_LIST' => 40,
487             '_PLUS_LIST' => 41,
488             'Critic_42' => 42,
489             '_PAREN' => 43,
490             '_OPTIONAL' => 44,
491             '_OPTIONAL' => 45,
492             '_PAREN' => 46,
493             '_OPTIONAL' => 47,
494             '_OPTIONAL' => 48,
495             'Exports_49' => 49,
496             'Include_50' => 50,
497             'Include_51' => 51,
498             'Constant_52' => 52,
499             '_OPTIONAL' => 53,
500             '_OPTIONAL' => 54,
501             '_STAR_LIST' => 55,
502             '_STAR_LIST' => 56,
503             'Subroutine_57' => 57,
504             '_PAREN' => 58,
505             '_STAR_LIST' => 59,
506             '_STAR_LIST' => 60,
507             'SubroutineArguments_61' => 61,
508             '_STAR_LIST' => 62,
509             '_STAR_LIST' => 63,
510             '_OPTIONAL' => 64,
511             '_OPTIONAL' => 65,
512             '_STAR_LIST' => 66,
513             '_STAR_LIST' => 67,
514             '_STAR_LIST' => 68,
515             '_STAR_LIST' => 69,
516             '_STAR_LIST' => 70,
517             '_STAR_LIST' => 71,
518             'Class_72' => 72,
519             '_PAREN' => 73,
520             '_STAR_LIST' => 74,
521             '_STAR_LIST' => 75,
522             'Properties_76' => 76,
523             'Properties_77' => 77,
524             '_OPTIONAL' => 78,
525             '_OPTIONAL' => 79,
526             '_STAR_LIST' => 80,
527             '_STAR_LIST' => 81,
528             'Method_82' => 82,
529             '_PAREN' => 83,
530             '_STAR_LIST' => 84,
531             '_STAR_LIST' => 85,
532             'MethodArguments_86' => 86,
533             'SubroutineOrMethod_87' => 87,
534             'SubroutineOrMethod_88' => 88,
535             'Operation_89' => 89,
536             'Operation_90' => 90,
537             'Operation_91' => 91,
538             'Operation_92' => 92,
539             'Operator_93' => 93,
540             'Operator_94' => 94,
541             'Operator_95' => 95,
542             'Operator_96' => 96,
543             'Operator_97' => 97,
544             'Operator_98' => 98,
545             'Operator_99' => 99,
546             'Operator_100' => 100,
547             'Operator_101' => 101,
548             'Operator_102' => 102,
549             'Operator_103' => 103,
550             'Operator_104' => 104,
551             'Operator_105' => 105,
552             'Operator_106' => 106,
553             'Operator_107' => 107,
554             'Operator_108' => 108,
555             'Operator_109' => 109,
556             'Operator_110' => 110,
557             'Operator_111' => 111,
558             'Operator_112' => 112,
559             'Operator_113' => 113,
560             'Operator_114' => 114,
561             'Operator_115' => 115,
562             'Operator_116' => 116,
563             'Operator_117' => 117,
564             'Operator_118' => 118,
565             'Operator_119' => 119,
566             'Operator_120' => 120,
567             'Operator_121' => 121,
568             'Operator_122' => 122,
569             'Operator_123' => 123,
570             '_PAREN' => 124,
571             '_OPTIONAL' => 125,
572             '_OPTIONAL' => 126,
573             '_OPTIONAL' => 127,
574             '_OPTIONAL' => 128,
575             'OperatorVoid_129' => 129,
576             'OperatorVoid_130' => 130,
577             'OperatorVoid_131' => 131,
578             'OperatorVoid_132' => 132,
579             'OperatorVoid_133' => 133,
580             'OperatorVoid_134' => 134,
581             'OperatorVoid_135' => 135,
582             'OperatorVoid_136' => 136,
583             '_OPTIONAL' => 137,
584             '_OPTIONAL' => 138,
585             '_OPTIONAL' => 139,
586             '_OPTIONAL' => 140,
587             '_OPTIONAL' => 141,
588             '_OPTIONAL' => 142,
589             'Expression_143' => 143,
590             'Expression_144' => 144,
591             'Expression_145' => 145,
592             'Expression_146' => 146,
593             'Expression_147' => 147,
594             'Expression_148' => 148,
595             'SubExpression_149' => 149,
596             'SubExpression_150' => 150,
597             'SubExpression_151' => 151,
598             'SubExpression_152' => 152,
599             'SubExpression_153' => 153,
600             'SubExpression_154' => 154,
601             'SubExpression_155' => 155,
602             'SubExpression_156' => 156,
603             'SubExpression_157' => 157,
604             'SubExpressionOrInput_158' => 158,
605             'SubExpressionOrInput_159' => 159,
606             'SubExpressionOrInput_160' => 160,
607             'SubExpressionOrVarMod_161' => 161,
608             'SubExpressionOrVarMod_162' => 162,
609             '_PAREN' => 163,
610             '_OPTIONAL' => 164,
611             '_OPTIONAL' => 165,
612             'Statement_166' => 166,
613             'Statement_167' => 167,
614             'Statement_168' => 168,
615             'Statement_169' => 169,
616             'Statement_170' => 170,
617             '_PAREN' => 171,
618             '_STAR_LIST' => 172,
619             '_STAR_LIST' => 173,
620             '_PAREN' => 174,
621             '_OPTIONAL' => 175,
622             '_OPTIONAL' => 176,
623             'Conditional_177' => 177,
624             'Loop_178' => 178,
625             'Loop_179' => 179,
626             'Loop_180' => 180,
627             'LoopFor_181' => 181,
628             'LoopFor_182' => 182,
629             'LoopForEach_183' => 183,
630             'LoopWhile_184' => 184,
631             'LoopWhile_185' => 185,
632             '_PLUS_LIST' => 186,
633             '_PLUS_LIST' => 187,
634             'CodeBlock_188' => 188,
635             '_STAR_LIST' => 189,
636             '_STAR_LIST' => 190,
637             'Variable_191' => 191,
638             'VariableRetrieval_192' => 192,
639             'VariableRetrieval_193' => 193,
640             'VariableRetrieval_194' => 194,
641             'VariableDeclaration_195' => 195,
642             'VariableDeclaration_196' => 196,
643             'VariableDeclaration_197' => 197,
644             'VariableDeclaration_198' => 198,
645             'VariableModification_199' => 199,
646             'VariableModification_200' => 200,
647             '_PAREN' => 201,
648             '_STAR_LIST' => 202,
649             '_STAR_LIST' => 203,
650             'ListElements_204' => 204,
651             'ListElement_205' => 205,
652             'ListElement_206' => 206,
653             'ListElement_207' => 207,
654             'ListElement_208' => 208,
655             '_OPTIONAL' => 209,
656             '_OPTIONAL' => 210,
657             'ArrayReference_211' => 211,
658             '_OPTIONAL' => 212,
659             '_OPTIONAL' => 213,
660             'ArrayDereference_214' => 214,
661             'ArrayDereference_215' => 215,
662             '_OPTIONAL' => 216,
663             '_OPTIONAL' => 217,
664             'HashEntry_218' => 218,
665             'HashEntry_219' => 219,
666             'HashEntry_220' => 220,
667             'HashEntryProperties_221' => 221,
668             '_PAREN' => 222,
669             '_STAR_LIST' => 223,
670             '_STAR_LIST' => 224,
671             'HashReference_225' => 225,
672             'HashReference_226' => 226,
673             '_OPTIONAL' => 227,
674             '_OPTIONAL' => 228,
675             'HashDereference_229' => 229,
676             'HashDereference_230' => 230,
677             'WordScoped_231' => 231,
678             'WordScoped_232' => 232,
679             'LoopLabel_233' => 233,
680             'Type_234' => 234,
681             'Type_235' => 235,
682             'Type_236' => 236,
683             'TypeInner_237' => 237,
684             'TypeInnerProperties_238' => 238,
685             'TypeInnerProperties_239' => 239,
686             'TypeInnerConstant_240' => 240,
687             'VariableOrLiteral_241' => 241,
688             'VariableOrLiteral_242' => 242,
689             'VarOrLitOrOpStrOrWord_243' => 243,
690             'VarOrLitOrOpStrOrWord_244' => 244,
691             'VarOrLitOrOpStrOrWord_245' => 245,
692             'VariableSymbolOrSelf_246' => 246,
693             'VariableSymbolOrSelf_247' => 247,
694             'Literal_248' => 248,
695             'Literal_249' => 249,
696             'OpNamedScolonOrSubExp_250' => 250,
697             'OpNamedScolonOrSubExp_251' => 251,
698             'OpNamedScolonOrSubExp_252' => 252,
699             'OpNamedScolonOrSubExpIn_253' => 253,
700             'OpNamedScolonOrSubExpIn_254' => 254,
701             'OpNamedScolonOrSubExpIn_255' => 255,
702             'OpStringOrWord_256' => 256,
703             'OpStringOrWord_257' => 257,
704             'OpStringOrWord_258' => 258,
705             'OpStringOrWord_259' => 259,
706             'OpStringOrWord_260' => 260,
707             'OpStringOrWord_261' => 261,
708             'OpStringOrWord_262' => 262,
709             'OpStringOrWord_263' => 263,
710             'OpStringOrWord_264' => 264,
711             'OpStringOrWord_265' => 265,
712             'OpStringOrWord_266' => 266,
713             'OpStringOrWord_267' => 267,
714             'OpStringOrWord_268' => 268,
715             'OpStringOrWord_269' => 269,
716             'OpStringOrWord_270' => 270,
717             'OpStringOrWord_271' => 271,
718             'OpStringOrWord_272' => 272,
719             },
720             yyTERMS =>
721             { '' => { ISSEMANTIC => 0 },
722             '## no critic qw(' => { ISSEMANTIC => 0 },
723             '$RETURN_TYPE' => { ISSEMANTIC => 0 },
724             '$TYPED_' => { ISSEMANTIC => 0 },
725             '%{' => { ISSEMANTIC => 0 },
726             ')' => { ISSEMANTIC => 0 },
727             ';' => { ISSEMANTIC => 0 },
728             '@ARG;' => { ISSEMANTIC => 0 },
729             '@{' => { ISSEMANTIC => 0 },
730             ']' => { ISSEMANTIC => 0 },
731             'else' => { ISSEMANTIC => 0 },
732             'elsif' => { ISSEMANTIC => 0 },
733             'for' => { ISSEMANTIC => 0 },
734             'foreach' => { ISSEMANTIC => 0 },
735             'if' => { ISSEMANTIC => 0 },
736             'our hashref $properties' => { ISSEMANTIC => 0 },
737             'package' => { ISSEMANTIC => 0 },
738             'undef' => { ISSEMANTIC => 0 },
739             'use constant' => { ISSEMANTIC => 0 },
740             'use parent qw(' => { ISSEMANTIC => 0 },
741             'use strict;' => { ISSEMANTIC => 0 },
742             'use warnings;' => { ISSEMANTIC => 0 },
743             'while' => { ISSEMANTIC => 0 },
744             '}' => { ISSEMANTIC => 0 },
745             ARGV => { ISSEMANTIC => 1 },
746             COLON => { ISSEMANTIC => 1 },
747             CONSTANT_CALL_SCOPED => { ISSEMANTIC => 1 },
748             ENV => { ISSEMANTIC => 1 },
749             FHREF_SYMBOL => { ISSEMANTIC => 1 },
750             FHREF_SYMBOL_BRACES => { ISSEMANTIC => 1 },
751             FHREF_SYMBOL_IN => { ISSEMANTIC => 1 },
752             LBRACE => { ISSEMANTIC => 1 },
753             LBRACKET => { ISSEMANTIC => 1 },
754             LITERAL_NUMBER => { ISSEMANTIC => 1 },
755             LITERAL_STRING => { ISSEMANTIC => 1 },
756             LPAREN => { ISSEMANTIC => 1 },
757             LPAREN_MY => { ISSEMANTIC => 1 },
758             MY => { ISSEMANTIC => 1 },
759             OP01_CLOSE => { ISSEMANTIC => 1 },
760             OP01_NAMED => { ISSEMANTIC => 1 },
761             OP01_NAMED_SCOLON => { ISSEMANTIC => 1 },
762             OP01_NAMED_VOID => { ISSEMANTIC => 1 },
763             OP01_NAMED_VOID_LPAREN => { ISSEMANTIC => 1 },
764             OP01_NAMED_VOID_SCOLON => { ISSEMANTIC => 1 },
765             OP01_OPEN => { ISSEMANTIC => 1 },
766             OP01_PRINT => { ISSEMANTIC => 1 },
767             OP01_QW => { ISSEMANTIC => 1 },
768             OP02_ARRAY_THINARROW => { ISSEMANTIC => 1 },
769             OP02_HASH_THINARROW => { ISSEMANTIC => 1 },
770             OP02_METHOD_THINARROW => { ISSEMANTIC => 1 },
771             OP02_METHOD_THINARROW_NEW => { ISSEMANTIC => 1 },
772             OP03_MATH_INC_DEC => { ISSEMANTIC => 1 },
773             OP04_MATH_POW => { ISSEMANTIC => 1 },
774             OP05_BITWISE_NEG_LPAREN => { ISSEMANTIC => 1 },
775             OP05_LOGICAL_NEG => { ISSEMANTIC => 1 },
776             OP05_MATH_NEG_LPAREN => { ISSEMANTIC => 1 },
777             OP06_REGEX_BIND => { ISSEMANTIC => 1 },
778             OP06_REGEX_PATTERN => { ISSEMANTIC => 1 },
779             OP07_MATH_MULT_DIV_MOD => { ISSEMANTIC => 1 },
780             OP07_STRING_REPEAT => { ISSEMANTIC => 1 },
781             OP08_MATH_ADD_SUB => { ISSEMANTIC => 1 },
782             OP08_STRING_CAT => { ISSEMANTIC => 1 },
783             OP09_BITWISE_SHIFT => { ISSEMANTIC => 1 },
784             OP10_NAMED_UNARY => { ISSEMANTIC => 1 },
785             OP10_NAMED_UNARY_SCOLON => { ISSEMANTIC => 1 },
786             OP11_COMPARE_LT_GT => { ISSEMANTIC => 1 },
787             OP12_COMPARE_EQ_NE => { ISSEMANTIC => 1 },
788             OP13_BITWISE_AND => { ISSEMANTIC => 1 },
789             OP14_BITWISE_OR_XOR => { ISSEMANTIC => 1 },
790             OP15_LOGICAL_AND => { ISSEMANTIC => 1 },
791             OP16_LOGICAL_OR => { ISSEMANTIC => 1 },
792             OP17_LIST_RANGE => { ISSEMANTIC => 1 },
793             OP18_TERNARY => { ISSEMANTIC => 1 },
794             OP19_LOOP_CONTROL => { ISSEMANTIC => 1 },
795             OP19_LOOP_CONTROL_SCOLON => { ISSEMANTIC => 1 },
796             OP19_VARIABLE_ASSIGN => { ISSEMANTIC => 1 },
797             OP19_VARIABLE_ASSIGN_BY => { ISSEMANTIC => 1 },
798             OP20_HASH_FATARROW => { ISSEMANTIC => 1 },
799             OP21_LIST_COMMA => { ISSEMANTIC => 1 },
800             OP22_LOGICAL_NEG => { ISSEMANTIC => 1 },
801             OP22_LOGICAL_NEG_LPAREN => { ISSEMANTIC => 1 },
802             OP23_LOGICAL_AND => { ISSEMANTIC => 1 },
803             OP24_LOGICAL_OR_XOR => { ISSEMANTIC => 1 },
804             OUR => { ISSEMANTIC => 1 },
805             OUR_EXPORT => { ISSEMANTIC => 1 },
806             OUR_EXPORT_OK => { ISSEMANTIC => 1 },
807             SELF => { ISSEMANTIC => 1 },
808             SHEBANG => { ISSEMANTIC => 1 },
809             STDIN => { ISSEMANTIC => 1 },
810             STDOUT_STDERR => { ISSEMANTIC => 1 },
811             SUB => { ISSEMANTIC => 1 },
812             TYPE_FHREF => { ISSEMANTIC => 1 },
813             TYPE_INTEGER => { ISSEMANTIC => 1 },
814             TYPE_METHOD => { ISSEMANTIC => 1 },
815             USE => { ISSEMANTIC => 1 },
816             USE_EXPORTER => { ISSEMANTIC => 1 },
817             USE_RPERL => { ISSEMANTIC => 1 },
818             USE_RPERL_AFTER => { ISSEMANTIC => 1 },
819             VARIABLE_SYMBOL => { ISSEMANTIC => 1 },
820             VERSION_NUMBER_ASSIGN => { ISSEMANTIC => 1 },
821             WORD => { ISSEMANTIC => 1 },
822             WORD_SCOPED => { ISSEMANTIC => 1 },
823             WORD_UPPERCASE => { ISSEMANTIC => 1 },
824             error => { ISSEMANTIC => 0 },
825             },
826             yyFILENAME => 'lib/RPerl/Grammar.eyp',
827             yystates =>
828             [
829             {#State 0
830             ACTIONS => {
831             'SHEBANG' => 9,
832             "## no critic qw(" => 6,
833             'USE_RPERL' => -20,
834             "package" => -20
835             },
836             GOTOS => {
837             'CompileUnit' => 4,
838             'Critic' => 7,
839             'OPTIONAL-9' => 5,
840             'PLUS-2' => 8,
841             'ModuleHeader' => 1,
842             'Program' => 2,
843             'PAREN-1' => 3
844             }
845             },
846             {#State 1
847             ACTIONS => {
848             'USE' => -27,
849             'SUB' => -27,
850             "use parent qw(" => 11,
851             'USE_EXPORTER' => -27,
852             "## no critic qw(" => -27,
853             "use constant" => -27
854             },
855             GOTOS => {
856             'Package' => 12,
857             'Class' => 10,
858             'STAR-11' => 14,
859             'Module' => 13
860             }
861             },
862             {#State 2
863             DEFAULT => -4
864             },
865             {#State 3
866             DEFAULT => -3
867             },
868             {#State 4
869             ACTIONS => {
870             '' => 15
871             }
872             },
873             {#State 5
874             ACTIONS => {
875             "package" => -22,
876             'USE_RPERL' => 16
877             },
878             GOTOS => {
879             'OPTIONAL-10' => 17
880             }
881             },
882             {#State 6
883             ACTIONS => {
884             'WORD' => 18
885             },
886             GOTOS => {
887             'PLUS-17' => 19
888             }
889             },
890             {#State 7
891             DEFAULT => -19
892             },
893             {#State 8
894             ACTIONS => {
895             "## no critic qw(" => 6,
896             'USE_RPERL' => -20,
897             '' => -5,
898             "package" => -20
899             },
900             GOTOS => {
901             'OPTIONAL-9' => 5,
902             'Critic' => 7,
903             'PAREN-1' => 20,
904             'ModuleHeader' => 1
905             }
906             },
907             {#State 9
908             ACTIONS => {
909             "## no critic qw(" => 6,
910             'USE_RPERL' => -7
911             },
912             GOTOS => {
913             'Critic' => 21,
914             'OPTIONAL-3' => 22
915             }
916             },
917             {#State 10
918             DEFAULT => -25
919             },
920             {#State 11
921             ACTIONS => {
922             'WORD' => 24,
923             'WORD_SCOPED' => 25
924             },
925             GOTOS => {
926             'WordScoped' => 23
927             }
928             },
929             {#State 12
930             DEFAULT => -24
931             },
932             {#State 13
933             DEFAULT => -1
934             },
935             {#State 14
936             ACTIONS => {
937             'USE' => -29,
938             'SUB' => -29,
939             'USE_EXPORTER' => 29,
940             "## no critic qw(" => 6,
941             "use constant" => -29
942             },
943             GOTOS => {
944             'Critic' => 26,
945             'Exports' => 27,
946             'OPTIONAL-12' => 28
947             }
948             },
949             {#State 15
950             DEFAULT => 0
951             },
952             {#State 16
953             DEFAULT => -21
954             },
955             {#State 17
956             ACTIONS => {
957             "package" => 30
958             }
959             },
960             {#State 18
961             DEFAULT => -41
962             },
963             {#State 19
964             ACTIONS => {
965             'WORD' => 32,
966             ")" => 31
967             }
968             },
969             {#State 20
970             DEFAULT => -2
971             },
972             {#State 21
973             DEFAULT => -6
974             },
975             {#State 22
976             ACTIONS => {
977             'USE_RPERL' => 33
978             }
979             },
980             {#State 23
981             ACTIONS => {
982             ")" => 34
983             }
984             },
985             {#State 24
986             DEFAULT => -231
987             },
988             {#State 25
989             DEFAULT => -232
990             },
991             {#State 26
992             DEFAULT => -26
993             },
994             {#State 27
995             DEFAULT => -28
996             },
997             {#State 28
998             DEFAULT => -31,
999             GOTOS => {
1000             'STAR-13' => 35
1001             }
1002             },
1003             {#State 29
1004             ACTIONS => {
1005             "use constant" => -45,
1006             'OUR_EXPORT_OK' => -45,
1007             'OUR_EXPORT' => 36,
1008             "our hashref \$properties" => -45,
1009             'USE' => -45,
1010             'SUB' => -45
1011             },
1012             GOTOS => {
1013             'PAREN-18' => 38,
1014             'OPTIONAL-19' => 37
1015             }
1016             },
1017             {#State 30
1018             ACTIONS => {
1019             'WORD_SCOPED' => 25,
1020             'WORD' => 24
1021             },
1022             GOTOS => {
1023             'WordScoped' => 39
1024             }
1025             },
1026             {#State 31
1027             DEFAULT => -42
1028             },
1029             {#State 32
1030             DEFAULT => -40
1031             },
1032             {#State 33
1033             ACTIONS => {
1034             "use strict;" => 40
1035             },
1036             GOTOS => {
1037             'Header' => 41
1038             }
1039             },
1040             {#State 34
1041             ACTIONS => {
1042             ";" => 42
1043             }
1044             },
1045             {#State 35
1046             ACTIONS => {
1047             "use constant" => -33,
1048             'SUB' => -33,
1049             'USE' => 43
1050             },
1051             GOTOS => {
1052             'STAR-14' => 45,
1053             'Include' => 44
1054             }
1055             },
1056             {#State 36
1057             ACTIONS => {
1058             'OP01_QW' => 46
1059             }
1060             },
1061             {#State 37
1062             ACTIONS => {
1063             'OUR_EXPORT_OK' => 49,
1064             "use constant" => -48,
1065             "our hashref \$properties" => -48,
1066             'SUB' => -48,
1067             'USE' => -48
1068             },
1069             GOTOS => {
1070             'PAREN-20' => 48,
1071             'OPTIONAL-21' => 47
1072             }
1073             },
1074             {#State 38
1075             DEFAULT => -44
1076             },
1077             {#State 39
1078             ACTIONS => {
1079             ";" => 50
1080             }
1081             },
1082             {#State 40
1083             ACTIONS => {
1084             "use warnings;" => 51
1085             }
1086             },
1087             {#State 41
1088             DEFAULT => -9,
1089             GOTOS => {
1090             'STAR-4' => 52
1091             }
1092             },
1093             {#State 42
1094             ACTIONS => {
1095             'USE' => 43
1096             },
1097             GOTOS => {
1098             'Include' => 53
1099             }
1100             },
1101             {#State 43
1102             ACTIONS => {
1103             'WORD' => 24,
1104             'WORD_SCOPED' => 25
1105             },
1106             GOTOS => {
1107             'WordScoped' => 54
1108             }
1109             },
1110             {#State 44
1111             DEFAULT => -30
1112             },
1113             {#State 45
1114             ACTIONS => {
1115             "use constant" => 57,
1116             'SUB' => 58
1117             },
1118             GOTOS => {
1119             'PLUS-15' => 59,
1120             'Subroutine' => 55,
1121             'Constant' => 56
1122             }
1123             },
1124             {#State 46
1125             ACTIONS => {
1126             ";" => 60
1127             }
1128             },
1129             {#State 47
1130             DEFAULT => -49
1131             },
1132             {#State 48
1133             DEFAULT => -47
1134             },
1135             {#State 49
1136             ACTIONS => {
1137             'OP01_QW' => 61
1138             }
1139             },
1140             {#State 50
1141             ACTIONS => {
1142             "use strict;" => 40
1143             },
1144             GOTOS => {
1145             'Header' => 62
1146             }
1147             },
1148             {#State 51
1149             ACTIONS => {
1150             'OUR' => -38,
1151             'USE_RPERL_AFTER' => 63
1152             },
1153             GOTOS => {
1154             'OPTIONAL-16' => 64
1155             }
1156             },
1157             {#State 52
1158             ACTIONS => {
1159             'OP01_NAMED_VOID_SCOLON' => -11,
1160             "if" => -11,
1161             'OP05_MATH_NEG_LPAREN' => -11,
1162             'LBRACKET' => -11,
1163             'LPAREN' => -11,
1164             'WORD_UPPERCASE' => -11,
1165             'MY' => -11,
1166             'OP10_NAMED_UNARY_SCOLON' => -11,
1167             'WORD' => -11,
1168             "foreach" => -11,
1169             'LITERAL_STRING' => -11,
1170             'OP05_BITWISE_NEG_LPAREN' => -11,
1171             'OP05_LOGICAL_NEG' => -11,
1172             "while" => -11,
1173             "## no critic qw(" => 6,
1174             'SELF' => -11,
1175             "for" => -11,
1176             'OP19_LOOP_CONTROL_SCOLON' => -11,
1177             "use constant" => -11,
1178             'LBRACE' => -11,
1179             'SUB' => -11,
1180             "\@{" => -11,
1181             'OP19_LOOP_CONTROL' => -11,
1182             'OP01_NAMED' => -11,
1183             'LITERAL_NUMBER' => -11,
1184             'OP01_CLOSE' => -11,
1185             'OP01_OPEN' => -11,
1186             "%{" => -11,
1187             'OP03_MATH_INC_DEC' => -11,
1188             'CONSTANT_CALL_SCOPED' => -11,
1189             'OP22_LOGICAL_NEG' => -11,
1190             'OP01_NAMED_VOID_LPAREN' => -11,
1191             'OP01_NAMED_SCOLON' => -11,
1192             'OP22_LOGICAL_NEG_LPAREN' => -11,
1193             'OP01_NAMED_VOID' => -11,
1194             'WORD_SCOPED' => -11,
1195             'OP10_NAMED_UNARY' => -11,
1196             'OP01_PRINT' => -11,
1197             'VARIABLE_SYMBOL' => -11,
1198             "undef" => -11,
1199             'USE' => -11
1200             },
1201             GOTOS => {
1202             'Critic' => 66,
1203             'STAR-5' => 65
1204             }
1205             },
1206             {#State 53
1207             DEFAULT => -63,
1208             GOTOS => {
1209             'STAR-26' => 67
1210             }
1211             },
1212             {#State 54
1213             ACTIONS => {
1214             ";" => 68,
1215             'OP01_QW' => 69
1216             }
1217             },
1218             {#State 55
1219             DEFAULT => -35
1220             },
1221             {#State 56
1222             DEFAULT => -32
1223             },
1224             {#State 57
1225             ACTIONS => {
1226             'WORD_UPPERCASE' => 70
1227             }
1228             },
1229             {#State 58
1230             ACTIONS => {
1231             'WORD' => 71
1232             }
1233             },
1234             {#State 59
1235             ACTIONS => {
1236             'LITERAL_NUMBER' => 72,
1237             'SUB' => 58
1238             },
1239             GOTOS => {
1240             'Subroutine' => 73
1241             }
1242             },
1243             {#State 60
1244             DEFAULT => -43
1245             },
1246             {#State 61
1247             ACTIONS => {
1248             ";" => 74
1249             }
1250             },
1251             {#State 62
1252             DEFAULT => -23
1253             },
1254             {#State 63
1255             DEFAULT => -37
1256             },
1257             {#State 64
1258             ACTIONS => {
1259             'OUR' => 75
1260             }
1261             },
1262             {#State 65
1263             ACTIONS => {
1264             'LITERAL_STRING' => -13,
1265             'OP05_BITWISE_NEG_LPAREN' => -13,
1266             "foreach" => -13,
1267             'WORD' => -13,
1268             'OP05_LOGICAL_NEG' => -13,
1269             "if" => -13,
1270             'OP01_NAMED_VOID_SCOLON' => -13,
1271             'MY' => -13,
1272             'OP10_NAMED_UNARY_SCOLON' => -13,
1273             'LPAREN' => -13,
1274             'WORD_UPPERCASE' => -13,
1275             'LBRACKET' => -13,
1276             'OP05_MATH_NEG_LPAREN' => -13,
1277             'OP19_LOOP_CONTROL_SCOLON' => -13,
1278             "while" => -13,
1279             "for" => -13,
1280             'SELF' => -13,
1281             'LITERAL_NUMBER' => -13,
1282             'OP01_NAMED' => -13,
1283             'OP19_LOOP_CONTROL' => -13,
1284             'OP01_OPEN' => -13,
1285             'OP01_CLOSE' => -13,
1286             'LBRACE' => -13,
1287             "use constant" => -13,
1288             "\@{" => -13,
1289             'SUB' => -13,
1290             'OP10_NAMED_UNARY' => -13,
1291             'OP22_LOGICAL_NEG_LPAREN' => -13,
1292             'OP01_NAMED_VOID' => -13,
1293             'WORD_SCOPED' => -13,
1294             'USE' => 43,
1295             "undef" => -13,
1296             'VARIABLE_SYMBOL' => -13,
1297             'OP01_PRINT' => -13,
1298             'CONSTANT_CALL_SCOPED' => -13,
1299             'OP03_MATH_INC_DEC' => -13,
1300             "%{" => -13,
1301             'OP01_NAMED_VOID_LPAREN' => -13,
1302             'OP01_NAMED_SCOLON' => -13,
1303             'OP22_LOGICAL_NEG' => -13
1304             },
1305             GOTOS => {
1306             'STAR-6' => 77,
1307             'Include' => 76
1308             }
1309             },
1310             {#State 66
1311             DEFAULT => -8
1312             },
1313             {#State 67
1314             ACTIONS => {
1315             'USE' => -65,
1316             "our hashref \$properties" => -65,
1317             'USE_EXPORTER' => 29,
1318             "## no critic qw(" => 6,
1319             "use constant" => -65
1320             },
1321             GOTOS => {
1322             'Exports' => 78,
1323             'OPTIONAL-27' => 79,
1324             'Critic' => 80
1325             }
1326             },
1327             {#State 68
1328             DEFAULT => -50
1329             },
1330             {#State 69
1331             ACTIONS => {
1332             ";" => 81
1333             }
1334             },
1335             {#State 70
1336             ACTIONS => {
1337             'OP20_HASH_FATARROW' => 82
1338             }
1339             },
1340             {#State 71
1341             ACTIONS => {
1342             'LBRACE' => 83
1343             }
1344             },
1345             {#State 72
1346             ACTIONS => {
1347             ";" => 84
1348             }
1349             },
1350             {#State 73
1351             DEFAULT => -34
1352             },
1353             {#State 74
1354             DEFAULT => -46
1355             },
1356             {#State 75
1357             ACTIONS => {
1358             'VERSION_NUMBER_ASSIGN' => 85
1359             }
1360             },
1361             {#State 76
1362             DEFAULT => -10
1363             },
1364             {#State 77
1365             ACTIONS => {
1366             'OP22_LOGICAL_NEG_LPAREN' => -15,
1367             'OP01_NAMED_VOID' => -15,
1368             'WORD_SCOPED' => -15,
1369             'OP10_NAMED_UNARY' => -15,
1370             "undef" => -15,
1371             'VARIABLE_SYMBOL' => -15,
1372             'OP01_PRINT' => -15,
1373             'CONSTANT_CALL_SCOPED' => -15,
1374             'OP03_MATH_INC_DEC' => -15,
1375             "%{" => -15,
1376             'OP22_LOGICAL_NEG' => -15,
1377             'OP01_NAMED_VOID_LPAREN' => -15,
1378             'OP01_NAMED_SCOLON' => -15,
1379             'OP19_LOOP_CONTROL' => -15,
1380             'OP01_NAMED' => -15,
1381             'LITERAL_NUMBER' => -15,
1382             'OP01_CLOSE' => -15,
1383             'OP01_OPEN' => -15,
1384             "use constant" => 57,
1385             'LBRACE' => -15,
1386             'SUB' => -15,
1387             "\@{" => -15,
1388             'OP19_LOOP_CONTROL_SCOLON' => -15,
1389             "while" => -15,
1390             'SELF' => -15,
1391             "for" => -15,
1392             'WORD' => -15,
1393             "foreach" => -15,
1394             'OP05_BITWISE_NEG_LPAREN' => -15,
1395             'LITERAL_STRING' => -15,
1396             'OP05_LOGICAL_NEG' => -15,
1397             'OP01_NAMED_VOID_SCOLON' => -15,
1398             "if" => -15,
1399             'OP05_MATH_NEG_LPAREN' => -15,
1400             'LBRACKET' => -15,
1401             'WORD_UPPERCASE' => -15,
1402             'LPAREN' => -15,
1403             'MY' => -15,
1404             'OP10_NAMED_UNARY_SCOLON' => -15
1405             },
1406             GOTOS => {
1407             'STAR-7' => 86,
1408             'Constant' => 87
1409             }
1410             },
1411             {#State 78
1412             DEFAULT => -64
1413             },
1414             {#State 79
1415             DEFAULT => -67,
1416             GOTOS => {
1417             'STAR-28' => 88
1418             }
1419             },
1420             {#State 80
1421             DEFAULT => -62
1422             },
1423             {#State 81
1424             DEFAULT => -51
1425             },
1426             {#State 82
1427             ACTIONS => {
1428             'MY' => 90
1429             },
1430             GOTOS => {
1431             'TypeInnerConstant' => 89
1432             }
1433             },
1434             {#State 83
1435             ACTIONS => {
1436             'LBRACE' => 91
1437             }
1438             },
1439             {#State 84
1440             DEFAULT => -36
1441             },
1442             {#State 85
1443             DEFAULT => -39
1444             },
1445             {#State 86
1446             ACTIONS => {
1447             'OP22_LOGICAL_NEG' => 110,
1448             'OP01_NAMED_SCOLON' => 113,
1449             'OP01_NAMED_VOID_LPAREN' => 112,
1450             'OP03_MATH_INC_DEC' => 115,
1451             'CONSTANT_CALL_SCOPED' => 116,
1452             "%{" => 114,
1453             "undef" => 104,
1454             'OP01_PRINT' => 102,
1455             'VARIABLE_SYMBOL' => 103,
1456             'OP01_NAMED_VOID' => 107,
1457             'WORD_SCOPED' => 25,
1458             'OP22_LOGICAL_NEG_LPAREN' => 106,
1459             'OP10_NAMED_UNARY' => 109,
1460             'SUB' => 58,
1461             "\@{" => 99,
1462             'LBRACE' => 100,
1463             'OP01_CLOSE' => 93,
1464             'OP01_OPEN' => 92,
1465             'OP19_LOOP_CONTROL' => 96,
1466             'OP01_NAMED' => 97,
1467             'LITERAL_NUMBER' => 98,
1468             'SELF' => 143,
1469             "for" => -165,
1470             "while" => -165,
1471             'OP19_LOOP_CONTROL_SCOLON' => 138,
1472             'OP05_MATH_NEG_LPAREN' => 124,
1473             'LBRACKET' => 125,
1474             'WORD_UPPERCASE' => 129,
1475             'LPAREN' => 130,
1476             'MY' => 132,
1477             'OP10_NAMED_UNARY_SCOLON' => 131,
1478             'OP01_NAMED_VOID_SCOLON' => 133,
1479             "if" => 136,
1480             'OP05_LOGICAL_NEG' => 120,
1481             'WORD' => 24,
1482             "foreach" => -165,
1483             'OP05_BITWISE_NEG_LPAREN' => 122,
1484             'LITERAL_STRING' => 123
1485             },
1486             GOTOS => {
1487             'HashDereference' => 142,
1488             'VariableSymbolOrSelf' => 108,
1489             'SubExpression' => 141,
1490             'Statement' => 137,
1491             'ArrayDereference' => 139,
1492             'WordScoped' => 140,
1493             'Subroutine' => 105,
1494             'LoopLabel' => 144,
1495             'Operation' => 117,
1496             'Variable' => 145,
1497             'Operator' => 111,
1498             'VariableModification' => 121,
1499             'VariableDeclaration' => 94,
1500             'OperatorVoid' => 95,
1501             'Conditional' => 118,
1502             'PAREN-43' => 119,
1503             'Expression' => 135,
1504             'ArrayReference' => 134,
1505             'OPTIONAL-44' => 101,
1506             'HashReference' => 126,
1507             'PLUS-8' => 127,
1508             'Literal' => 128
1509             }
1510             },
1511             {#State 87
1512             DEFAULT => -12
1513             },
1514             {#State 88
1515             ACTIONS => {
1516             'USE' => 43,
1517             "our hashref \$properties" => -69,
1518             "use constant" => -69
1519             },
1520             GOTOS => {
1521             'Include' => 147,
1522             'STAR-29' => 146
1523             }
1524             },
1525             {#State 89
1526             ACTIONS => {
1527             'LITERAL_STRING' => 123,
1528             'LITERAL_NUMBER' => 98
1529             },
1530             GOTOS => {
1531             'Literal' => 148
1532             }
1533             },
1534             {#State 90
1535             ACTIONS => {
1536             'WORD' => 152,
1537             'WORD_SCOPED' => 150,
1538             'TYPE_INTEGER' => 149
1539             },
1540             GOTOS => {
1541             'Type' => 151
1542             }
1543             },
1544             {#State 91
1545             ACTIONS => {
1546             'MY' => 153
1547             }
1548             },
1549             {#State 92
1550             ACTIONS => {
1551             'MY' => 154
1552             }
1553             },
1554             {#State 93
1555             ACTIONS => {
1556             'FHREF_SYMBOL' => 155
1557             }
1558             },
1559             {#State 94
1560             DEFAULT => -169
1561             },
1562             {#State 95
1563             DEFAULT => -168
1564             },
1565             {#State 96
1566             ACTIONS => {
1567             'WORD_UPPERCASE' => 157
1568             },
1569             GOTOS => {
1570             'LoopLabel' => 156
1571             }
1572             },
1573             {#State 97
1574             ACTIONS => {
1575             'VARIABLE_SYMBOL' => 103,
1576             "undef" => 104,
1577             'OP22_LOGICAL_NEG_LPAREN' => 106,
1578             'WORD_SCOPED' => 25,
1579             'OP10_NAMED_UNARY' => 109,
1580             'OP01_QW' => 167,
1581             'SELF' => 143,
1582             'OP22_LOGICAL_NEG' => 110,
1583             'CONSTANT_CALL_SCOPED' => 116,
1584             "%{" => 114,
1585             'OP03_MATH_INC_DEC' => 115,
1586             'ARGV' => 166,
1587             'OP01_CLOSE' => 93,
1588             'OP01_OPEN' => 92,
1589             'OP05_LOGICAL_NEG' => 120,
1590             'WORD' => 24,
1591             'LITERAL_NUMBER' => 98,
1592             'OP01_NAMED' => 165,
1593             'LITERAL_STRING' => 123,
1594             'OP05_BITWISE_NEG_LPAREN' => 122,
1595             'OP05_MATH_NEG_LPAREN' => 124,
1596             'LBRACKET' => 125,
1597             'MY' => 160,
1598             'LPAREN' => 130,
1599             "\@{" => 99,
1600             'WORD_UPPERCASE' => 161,
1601             'LBRACE' => 100
1602             },
1603             GOTOS => {
1604             'Variable' => 164,
1605             'Expression' => 159,
1606             'ArrayReference' => 134,
1607             'Literal' => 128,
1608             'Operator' => 111,
1609             'HashReference' => 126,
1610             'SubExpression' => 162,
1611             'VariableSymbolOrSelf' => 108,
1612             'ListElement' => 158,
1613             'HashDereference' => 142,
1614             'ArrayDereference' => 139,
1615             'TypeInner' => 163,
1616             'WordScoped' => 140
1617             }
1618             },
1619             {#State 98
1620             DEFAULT => -248
1621             },
1622             {#State 99
1623             ACTIONS => {
1624             'SELF' => 143,
1625             'LBRACKET' => -213,
1626             'VARIABLE_SYMBOL' => 103,
1627             'MY' => 160
1628             },
1629             GOTOS => {
1630             'VariableSymbolOrSelf' => 108,
1631             'OPTIONAL-54' => 170,
1632             'Variable' => 168,
1633             'TypeInner' => 169
1634             }
1635             },
1636             {#State 100
1637             ACTIONS => {
1638             "}" => 175,
1639             'OP24_LOGICAL_OR_XOR' => 177,
1640             'OP01_OPEN' => 184,
1641             'OP01_CLOSE' => 185,
1642             'OP07_STRING_REPEAT' => 171,
1643             'LITERAL_NUMBER' => 98,
1644             'LITERAL_STRING' => 123,
1645             'OP01_NAMED' => 189,
1646             'OP11_COMPARE_LT_GT' => 188,
1647             'OP07_MATH_MULT_DIV_MOD' => 174,
1648             'ENV' => 186,
1649             'OP12_COMPARE_EQ_NE' => 172,
1650             'OP19_LOOP_CONTROL' => 187,
1651             'WORD' => 173,
1652             'OP08_MATH_ADD_SUB' => 180,
1653             'OP22_LOGICAL_NEG' => 195,
1654             'SELF' => 143,
1655             "%{" => 114,
1656             'OP23_LOGICAL_AND' => 181,
1657             'OP19_LOOP_CONTROL_SCOLON' => 178,
1658             'VARIABLE_SYMBOL' => 103,
1659             'OP01_PRINT' => 191,
1660             'OP10_NAMED_UNARY' => 193,
1661             'OP01_NAMED_VOID' => 192
1662             },
1663             GOTOS => {
1664             'HashEntry' => 190,
1665             'VariableSymbolOrSelf' => 108,
1666             'HashDereference' => 179,
1667             'Variable' => 182,
1668             'OpStringOrWord' => 194,
1669             'Literal' => 176,
1670             'VarOrLitOrOpStrOrWord' => 183
1671             }
1672             },
1673             {#State 101
1674             ACTIONS => {
1675             "for" => 197,
1676             "while" => 196,
1677             "foreach" => 198
1678             },
1679             GOTOS => {
1680             'LoopWhile' => 199,
1681             'LoopForEach' => 201,
1682             'Loop' => 202,
1683             'LoopFor' => 200
1684             }
1685             },
1686             {#State 102
1687             ACTIONS => {
1688             'OP10_NAMED_UNARY' => -126,
1689             'WORD_SCOPED' => -126,
1690             'OP22_LOGICAL_NEG_LPAREN' => -126,
1691             'FHREF_SYMBOL_BRACES' => 205,
1692             "undef" => -126,
1693             'VARIABLE_SYMBOL' => -126,
1694             'ARGV' => -126,
1695             'CONSTANT_CALL_SCOPED' => -126,
1696             'OP03_MATH_INC_DEC' => -126,
1697             "%{" => -126,
1698             'OP22_LOGICAL_NEG' => -126,
1699             'SELF' => -126,
1700             'OP01_QW' => -126,
1701             'OP05_BITWISE_NEG_LPAREN' => -126,
1702             'OP01_NAMED' => -126,
1703             'LITERAL_STRING' => -126,
1704             'LITERAL_NUMBER' => -126,
1705             'WORD' => -126,
1706             'OP01_OPEN' => -126,
1707             'OP05_LOGICAL_NEG' => -126,
1708             'OP01_CLOSE' => -126,
1709             'STDOUT_STDERR' => 204,
1710             'LBRACE' => -126,
1711             'WORD_UPPERCASE' => -126,
1712             "\@{" => -126,
1713             'LPAREN' => -126,
1714             'MY' => -126,
1715             'LBRACKET' => -126,
1716             'OP05_MATH_NEG_LPAREN' => -126
1717             },
1718             GOTOS => {
1719             'PAREN-37' => 203,
1720             'OPTIONAL-38' => 206
1721             }
1722             },
1723             {#State 103
1724             DEFAULT => -246
1725             },
1726             {#State 104
1727             DEFAULT => -150
1728             },
1729             {#State 105
1730             DEFAULT => -14
1731             },
1732             {#State 106
1733             ACTIONS => {
1734             'OP22_LOGICAL_NEG_LPAREN' => 106,
1735             'WORD_SCOPED' => 25,
1736             'OP10_NAMED_UNARY' => 109,
1737             'VARIABLE_SYMBOL' => 103,
1738             "undef" => 104,
1739             'CONSTANT_CALL_SCOPED' => 116,
1740             'OP03_MATH_INC_DEC' => 115,
1741             "%{" => 114,
1742             'SELF' => 143,
1743             'OP22_LOGICAL_NEG' => 110,
1744             'WORD' => 24,
1745             'LITERAL_NUMBER' => 98,
1746             'LITERAL_STRING' => 123,
1747             'OP01_NAMED' => 165,
1748             'OP05_BITWISE_NEG_LPAREN' => 122,
1749             'OP05_LOGICAL_NEG' => 120,
1750             'OP01_OPEN' => 92,
1751             'OP01_CLOSE' => 93,
1752             'LBRACE' => 100,
1753             'OP05_MATH_NEG_LPAREN' => 124,
1754             'LBRACKET' => 125,
1755             'WORD_UPPERCASE' => 161,
1756             "\@{" => 99,
1757             'LPAREN' => 130
1758             },
1759             GOTOS => {
1760             'WordScoped' => 140,
1761             'ArrayDereference' => 139,
1762             'HashDereference' => 142,
1763             'VariableSymbolOrSelf' => 108,
1764             'SubExpression' => 207,
1765             'HashReference' => 126,
1766             'Literal' => 128,
1767             'Operator' => 111,
1768             'ArrayReference' => 134,
1769             'Expression' => 159,
1770             'Variable' => 164
1771             }
1772             },
1773             {#State 107
1774             ACTIONS => {
1775             'OP01_QW' => 167,
1776             'SELF' => 143,
1777             'OP22_LOGICAL_NEG' => 110,
1778             'CONSTANT_CALL_SCOPED' => 116,
1779             'OP03_MATH_INC_DEC' => 115,
1780             "%{" => 114,
1781             'ARGV' => 166,
1782             "undef" => 104,
1783             'VARIABLE_SYMBOL' => 103,
1784             'OP22_LOGICAL_NEG_LPAREN' => 106,
1785             'WORD_SCOPED' => 25,
1786             'OP10_NAMED_UNARY' => 109,
1787             'OP05_MATH_NEG_LPAREN' => 124,
1788             'LBRACKET' => 125,
1789             'MY' => 160,
1790             'WORD_UPPERCASE' => 161,
1791             "\@{" => 99,
1792             'LPAREN' => 130,
1793             'LBRACE' => 100,
1794             'OP01_OPEN' => 92,
1795             'OP05_LOGICAL_NEG' => 120,
1796             'OP01_CLOSE' => 93,
1797             'WORD' => 24,
1798             'LITERAL_NUMBER' => 98,
1799             'LITERAL_STRING' => 123,
1800             'OP05_BITWISE_NEG_LPAREN' => 122,
1801             'OP01_NAMED' => 165
1802             },
1803             GOTOS => {
1804             'HashReference' => 126,
1805             'Literal' => 128,
1806             'Operator' => 111,
1807             'ListElements' => 208,
1808             'Expression' => 159,
1809             'ArrayReference' => 134,
1810             'Variable' => 164,
1811             'TypeInner' => 163,
1812             'ArrayDereference' => 139,
1813             'WordScoped' => 140,
1814             'VariableSymbolOrSelf' => 108,
1815             'HashDereference' => 142,
1816             'ListElement' => 209,
1817             'SubExpression' => 210
1818             }
1819             },
1820             {#State 108
1821             DEFAULT => -190,
1822             GOTOS => {
1823             'STAR-50' => 211
1824             }
1825             },
1826             {#State 109
1827             ACTIONS => {
1828             'OP24_LOGICAL_OR_XOR' => -111,
1829             'WORD_UPPERCASE' => 161,
1830             'LPAREN' => 130,
1831             "}" => -111,
1832             'LBRACKET' => 125,
1833             'OP17_LIST_RANGE' => -111,
1834             'OP05_MATH_NEG_LPAREN' => 124,
1835             ";" => -111,
1836             'LITERAL_STRING' => 123,
1837             'OP05_BITWISE_NEG_LPAREN' => 122,
1838             'OP07_MATH_MULT_DIV_MOD' => -111,
1839             'OP12_COMPARE_EQ_NE' => -111,
1840             'WORD' => 24,
1841             'OP05_LOGICAL_NEG' => 120,
1842             'OP14_BITWISE_OR_XOR' => -111,
1843             'OP07_STRING_REPEAT' => -111,
1844             'OP04_MATH_POW' => -111,
1845             'OP23_LOGICAL_AND' => -111,
1846             'OP08_MATH_ADD_SUB' => -111,
1847             'OP08_STRING_CAT' => -111,
1848             "]" => -111,
1849             'SELF' => 143,
1850             ")" => -111,
1851             'OP13_BITWISE_AND' => -111,
1852             'LBRACE' => 100,
1853             "\@{" => 99,
1854             'LITERAL_NUMBER' => 98,
1855             'OP01_NAMED' => 165,
1856             'OP11_COMPARE_LT_GT' => -111,
1857             'OP09_BITWISE_SHIFT' => -111,
1858             'OP21_LIST_COMMA' => -111,
1859             'OP01_OPEN' => 92,
1860             'OP15_LOGICAL_AND' => -111,
1861             'OP01_CLOSE' => 93,
1862             "%{" => 114,
1863             'OP03_MATH_INC_DEC' => 115,
1864             'CONSTANT_CALL_SCOPED' => 116,
1865             'OP22_LOGICAL_NEG' => 110,
1866             'OP16_LOGICAL_OR' => -111,
1867             'OP10_NAMED_UNARY' => 109,
1868             'WORD_SCOPED' => 25,
1869             'OP22_LOGICAL_NEG_LPAREN' => 106,
1870             "undef" => 104,
1871             'OP18_TERNARY' => -111,
1872             'VARIABLE_SYMBOL' => 103,
1873             'OP06_REGEX_BIND' => -111
1874             },
1875             GOTOS => {
1876             'Expression' => 159,
1877             'ArrayReference' => 134,
1878             'Variable' => 164,
1879             'HashReference' => 126,
1880             'Operator' => 111,
1881             'Literal' => 128,
1882             'SubExpression' => 212,
1883             'VariableSymbolOrSelf' => 108,
1884             'HashDereference' => 142,
1885             'ArrayDereference' => 139,
1886             'WordScoped' => 140
1887             }
1888             },
1889             {#State 110
1890             ACTIONS => {
1891             'SELF' => 143,
1892             'OP22_LOGICAL_NEG' => 110,
1893             'CONSTANT_CALL_SCOPED' => 116,
1894             "%{" => 114,
1895             'OP03_MATH_INC_DEC' => 115,
1896             'VARIABLE_SYMBOL' => 103,
1897             "undef" => 104,
1898             'OP22_LOGICAL_NEG_LPAREN' => 106,
1899             'WORD_SCOPED' => 25,
1900             'OP10_NAMED_UNARY' => 109,
1901             'LBRACKET' => 125,
1902             'OP05_MATH_NEG_LPAREN' => 124,
1903             'LPAREN' => 130,
1904             "\@{" => 99,
1905             'WORD_UPPERCASE' => 161,
1906             'LBRACE' => 100,
1907             'OP01_OPEN' => 92,
1908             'OP01_CLOSE' => 93,
1909             'OP05_LOGICAL_NEG' => 120,
1910             'WORD' => 24,
1911             'OP01_NAMED' => 165,
1912             'OP05_BITWISE_NEG_LPAREN' => 122,
1913             'LITERAL_STRING' => 123,
1914             'LITERAL_NUMBER' => 98
1915             },
1916             GOTOS => {
1917             'ArrayDereference' => 139,
1918             'WordScoped' => 140,
1919             'SubExpression' => 213,
1920             'HashDereference' => 142,
1921             'VariableSymbolOrSelf' => 108,
1922             'HashReference' => 126,
1923             'Literal' => 128,
1924             'Operator' => 111,
1925             'Expression' => 159,
1926             'ArrayReference' => 134,
1927             'Variable' => 164
1928             }
1929             },
1930             {#State 111
1931             DEFAULT => -143
1932             },
1933             {#State 112
1934             ACTIONS => {
1935             'VARIABLE_SYMBOL' => 103,
1936             "undef" => 104,
1937             'OP10_NAMED_UNARY' => 109,
1938             ")" => -128,
1939             'OP22_LOGICAL_NEG_LPAREN' => 106,
1940             'WORD_SCOPED' => 25,
1941             'OP22_LOGICAL_NEG' => 110,
1942             'OP01_QW' => 167,
1943             'SELF' => 143,
1944             'ARGV' => 166,
1945             'OP03_MATH_INC_DEC' => 115,
1946             'CONSTANT_CALL_SCOPED' => 116,
1947             "%{" => 114,
1948             'OP01_OPEN' => 92,
1949             'OP05_LOGICAL_NEG' => 120,
1950             'OP01_CLOSE' => 93,
1951             'LITERAL_NUMBER' => 98,
1952             'OP05_BITWISE_NEG_LPAREN' => 122,
1953             'LITERAL_STRING' => 123,
1954             'OP01_NAMED' => 165,
1955             'WORD' => 24,
1956             'MY' => 160,
1957             'LPAREN' => 130,
1958             'WORD_UPPERCASE' => 161,
1959             "\@{" => 99,
1960             'OP05_MATH_NEG_LPAREN' => 124,
1961             'LBRACKET' => 125,
1962             'LBRACE' => 100
1963             },
1964             GOTOS => {
1965             'SubExpression' => 210,
1966             'ListElement' => 209,
1967             'HashDereference' => 142,
1968             'VariableSymbolOrSelf' => 108,
1969             'WordScoped' => 140,
1970             'ArrayDereference' => 139,
1971             'TypeInner' => 163,
1972             'ArrayReference' => 134,
1973             'Expression' => 159,
1974             'Variable' => 164,
1975             'HashReference' => 126,
1976             'Literal' => 128,
1977             'Operator' => 111,
1978             'ListElements' => 214,
1979             'OPTIONAL-39' => 215
1980             }
1981             },
1982             {#State 113
1983             DEFAULT => -90
1984             },
1985             {#State 114
1986             ACTIONS => {
1987             'VARIABLE_SYMBOL' => 103,
1988             'MY' => 160,
1989             'SELF' => 143,
1990             'LBRACE' => -228
1991             },
1992             GOTOS => {
1993             'VariableSymbolOrSelf' => 108,
1994             'Variable' => 216,
1995             'OPTIONAL-58' => 218,
1996             'TypeInner' => 217
1997             }
1998             },
1999             {#State 115
2000             ACTIONS => {
2001             'SELF' => 143,
2002             'VARIABLE_SYMBOL' => 103
2003             },
2004             GOTOS => {
2005             'VariableSymbolOrSelf' => 108,
2006             'Variable' => 219
2007             }
2008             },
2009             {#State 116
2010             DEFAULT => -145
2011             },
2012             {#State 117
2013             DEFAULT => -17
2014             },
2015             {#State 118
2016             DEFAULT => -166
2017             },
2018             {#State 119
2019             DEFAULT => -164
2020             },
2021             {#State 120
2022             ACTIONS => {
2023             'LPAREN' => 130,
2024             "\@{" => 99,
2025             'WORD_UPPERCASE' => 161,
2026             'OP05_MATH_NEG_LPAREN' => 124,
2027             'LBRACKET' => 125,
2028             'LBRACE' => 100,
2029             'OP05_LOGICAL_NEG' => 120,
2030             'OP01_CLOSE' => 93,
2031             'OP01_OPEN' => 92,
2032             'OP05_BITWISE_NEG_LPAREN' => 122,
2033             'OP01_NAMED' => 165,
2034             'LITERAL_STRING' => 123,
2035             'LITERAL_NUMBER' => 98,
2036             'WORD' => 24,
2037             'OP22_LOGICAL_NEG' => 110,
2038             'SELF' => 143,
2039             'OP03_MATH_INC_DEC' => 115,
2040             "%{" => 114,
2041             'CONSTANT_CALL_SCOPED' => 116,
2042             "undef" => 104,
2043             'VARIABLE_SYMBOL' => 103,
2044             'OP10_NAMED_UNARY' => 109,
2045             'OP22_LOGICAL_NEG_LPAREN' => 106,
2046             'WORD_SCOPED' => 25
2047             },
2048             GOTOS => {
2049             'Expression' => 159,
2050             'ArrayReference' => 134,
2051             'Variable' => 164,
2052             'HashReference' => 126,
2053             'Literal' => 128,
2054             'Operator' => 111,
2055             'HashDereference' => 142,
2056             'VariableSymbolOrSelf' => 108,
2057             'SubExpression' => 220,
2058             'ArrayDereference' => 139,
2059             'WordScoped' => 140
2060             }
2061             },
2062             {#State 121
2063             ACTIONS => {
2064             ";" => 221
2065             }
2066             },
2067             {#State 122
2068             ACTIONS => {
2069             'SELF' => 143,
2070             'OP22_LOGICAL_NEG' => 110,
2071             "%{" => 114,
2072             'CONSTANT_CALL_SCOPED' => 116,
2073             'OP03_MATH_INC_DEC' => 115,
2074             'VARIABLE_SYMBOL' => 103,
2075             "undef" => 104,
2076             'OP22_LOGICAL_NEG_LPAREN' => 106,
2077             'WORD_SCOPED' => 25,
2078             'OP10_NAMED_UNARY' => 109,
2079             'OP05_MATH_NEG_LPAREN' => 124,
2080             'LBRACKET' => 125,
2081             "\@{" => 99,
2082             'LPAREN' => 130,
2083             'WORD_UPPERCASE' => 161,
2084             'LBRACE' => 100,
2085             'OP05_LOGICAL_NEG' => 120,
2086             'OP01_CLOSE' => 93,
2087             'OP01_OPEN' => 92,
2088             'WORD' => 24,
2089             'OP01_NAMED' => 165,
2090             'LITERAL_STRING' => 123,
2091             'OP05_BITWISE_NEG_LPAREN' => 122,
2092             'LITERAL_NUMBER' => 98
2093             },
2094             GOTOS => {
2095             'ArrayDereference' => 139,
2096             'WordScoped' => 140,
2097             'SubExpression' => 222,
2098             'VariableSymbolOrSelf' => 108,
2099             'HashDereference' => 142,
2100             'Operator' => 111,
2101             'Literal' => 128,
2102             'HashReference' => 126,
2103             'Variable' => 164,
2104             'Expression' => 159,
2105             'ArrayReference' => 134
2106             }
2107             },
2108             {#State 123
2109             DEFAULT => -249
2110             },
2111             {#State 124
2112             ACTIONS => {
2113             'OP01_OPEN' => 92,
2114             'OP01_CLOSE' => 93,
2115             'OP05_LOGICAL_NEG' => 120,
2116             'WORD' => 24,
2117             'LITERAL_STRING' => 123,
2118             'OP01_NAMED' => 165,
2119             'OP05_BITWISE_NEG_LPAREN' => 122,
2120             'LITERAL_NUMBER' => 98,
2121             'OP05_MATH_NEG_LPAREN' => 124,
2122             'LBRACKET' => 125,
2123             'LPAREN' => 130,
2124             "\@{" => 99,
2125             'WORD_UPPERCASE' => 161,
2126             'LBRACE' => 100,
2127             "undef" => 104,
2128             'VARIABLE_SYMBOL' => 103,
2129             'WORD_SCOPED' => 25,
2130             'OP22_LOGICAL_NEG_LPAREN' => 106,
2131             'OP10_NAMED_UNARY' => 109,
2132             'SELF' => 143,
2133             'OP22_LOGICAL_NEG' => 110,
2134             'OP03_MATH_INC_DEC' => 115,
2135             "%{" => 114,
2136             'CONSTANT_CALL_SCOPED' => 116
2137             },
2138             GOTOS => {
2139             'ArrayDereference' => 139,
2140             'WordScoped' => 140,
2141             'VariableSymbolOrSelf' => 108,
2142             'HashDereference' => 142,
2143             'SubExpression' => 223,
2144             'Literal' => 128,
2145             'Operator' => 111,
2146             'HashReference' => 126,
2147             'Variable' => 164,
2148             'Expression' => 159,
2149             'ArrayReference' => 134
2150             }
2151             },
2152             {#State 125
2153             ACTIONS => {
2154             'CONSTANT_CALL_SCOPED' => 116,
2155             "%{" => 114,
2156             'OP03_MATH_INC_DEC' => 115,
2157             'ARGV' => 166,
2158             'SELF' => 143,
2159             'OP01_QW' => 167,
2160             'OP22_LOGICAL_NEG' => 110,
2161             "]" => -210,
2162             'WORD_SCOPED' => 25,
2163             'OP22_LOGICAL_NEG_LPAREN' => 106,
2164             'OP10_NAMED_UNARY' => 109,
2165             "undef" => 104,
2166             'VARIABLE_SYMBOL' => 103,
2167             'LBRACE' => 100,
2168             'OP05_MATH_NEG_LPAREN' => 124,
2169             'LBRACKET' => 125,
2170             'LPAREN' => 130,
2171             "\@{" => 99,
2172             'WORD_UPPERCASE' => 161,
2173             'MY' => 160,
2174             'WORD' => 24,
2175             'OP01_NAMED' => 165,
2176             'LITERAL_STRING' => 123,
2177             'OP05_BITWISE_NEG_LPAREN' => 122,
2178             'LITERAL_NUMBER' => 98,
2179             'OP01_OPEN' => 92,
2180             'OP05_LOGICAL_NEG' => 120,
2181             'OP01_CLOSE' => 93
2182             },
2183             GOTOS => {
2184             'SubExpression' => 210,
2185             'ListElement' => 209,
2186             'VariableSymbolOrSelf' => 108,
2187             'HashDereference' => 142,
2188             'WordScoped' => 140,
2189             'ArrayDereference' => 139,
2190             'TypeInner' => 163,
2191             'Variable' => 164,
2192             'OPTIONAL-53' => 225,
2193             'Expression' => 159,
2194             'ArrayReference' => 134,
2195             'Operator' => 111,
2196             'ListElements' => 224,
2197             'Literal' => 128,
2198             'HashReference' => 126
2199             }
2200             },
2201             {#State 126
2202             DEFAULT => -155
2203             },
2204             {#State 127
2205             ACTIONS => {
2206             'OP19_LOOP_CONTROL_SCOLON' => 138,
2207             "while" => -165,
2208             '' => -18,
2209             "for" => -165,
2210             'SELF' => 143,
2211             'LITERAL_STRING' => 123,
2212             'OP05_BITWISE_NEG_LPAREN' => 122,
2213             "foreach" => -165,
2214             'WORD' => 24,
2215             'OP05_LOGICAL_NEG' => 120,
2216             "if" => 136,
2217             'OP01_NAMED_VOID_SCOLON' => 133,
2218             'OP10_NAMED_UNARY_SCOLON' => 131,
2219             'MY' => 132,
2220             'LPAREN' => 130,
2221             'WORD_UPPERCASE' => 129,
2222             'LBRACKET' => 125,
2223             'OP05_MATH_NEG_LPAREN' => 124,
2224             'OP10_NAMED_UNARY' => 109,
2225             'WORD_SCOPED' => 25,
2226             'OP01_NAMED_VOID' => 107,
2227             'OP22_LOGICAL_NEG_LPAREN' => 106,
2228             'OP01_PRINT' => 102,
2229             'VARIABLE_SYMBOL' => 103,
2230             "undef" => 104,
2231             'OP03_MATH_INC_DEC' => 115,
2232             "%{" => 114,
2233             'CONSTANT_CALL_SCOPED' => 116,
2234             'OP01_NAMED_VOID_LPAREN' => 112,
2235             'OP01_NAMED_SCOLON' => 113,
2236             'OP22_LOGICAL_NEG' => 110,
2237             'LITERAL_NUMBER' => 98,
2238             'OP01_NAMED' => 97,
2239             'OP19_LOOP_CONTROL' => 96,
2240             'OP01_CLOSE' => 93,
2241             'OP01_OPEN' => 92,
2242             'LBRACE' => 100,
2243             "\@{" => 99
2244             },
2245             GOTOS => {
2246             'PAREN-43' => 119,
2247             'Conditional' => 118,
2248             'OperatorVoid' => 95,
2249             'VariableDeclaration' => 94,
2250             'VariableModification' => 121,
2251             'HashReference' => 126,
2252             'Literal' => 128,
2253             'ArrayReference' => 134,
2254             'Expression' => 135,
2255             'OPTIONAL-44' => 101,
2256             'Statement' => 137,
2257             'WordScoped' => 140,
2258             'ArrayDereference' => 139,
2259             'SubExpression' => 141,
2260             'HashDereference' => 142,
2261             'VariableSymbolOrSelf' => 108,
2262             'Operator' => 111,
2263             'LoopLabel' => 144,
2264             'Variable' => 145,
2265             'Operation' => 226
2266             }
2267             },
2268             {#State 128
2269             DEFAULT => -151
2270             },
2271             {#State 129
2272             ACTIONS => {
2273             'LPAREN' => 227,
2274             'COLON' => -233
2275             }
2276             },
2277             {#State 130
2278             ACTIONS => {
2279             'OP10_NAMED_UNARY' => 109,
2280             'OP22_LOGICAL_NEG_LPAREN' => 106,
2281             'WORD_SCOPED' => 25,
2282             'VARIABLE_SYMBOL' => 103,
2283             'OP01_PRINT' => 228,
2284             "undef" => 104,
2285             'OP03_MATH_INC_DEC' => 115,
2286             'CONSTANT_CALL_SCOPED' => 116,
2287             "%{" => 114,
2288             'OP22_LOGICAL_NEG' => 110,
2289             'SELF' => 143,
2290             'LITERAL_NUMBER' => 98,
2291             'OP01_NAMED' => 229,
2292             'LITERAL_STRING' => 123,
2293             'OP05_BITWISE_NEG_LPAREN' => 122,
2294             'WORD' => 24,
2295             'OP05_LOGICAL_NEG' => 120,
2296             'OP01_CLOSE' => 93,
2297             'OP01_OPEN' => 92,
2298             'LBRACE' => 100,
2299             'WORD_UPPERCASE' => 161,
2300             'LPAREN' => 130,
2301             "\@{" => 99,
2302             'OP05_MATH_NEG_LPAREN' => 124,
2303             'LBRACKET' => 125
2304             },
2305             GOTOS => {
2306             'SubExpression' => 230,
2307             'HashDereference' => 142,
2308             'VariableSymbolOrSelf' => 108,
2309             'WordScoped' => 140,
2310             'ArrayDereference' => 139,
2311             'Variable' => 164,
2312             'Expression' => 159,
2313             'ArrayReference' => 134,
2314             'Operator' => 111,
2315             'Literal' => 128,
2316             'HashReference' => 126
2317             }
2318             },
2319             {#State 131
2320             DEFAULT => -91
2321             },
2322             {#State 132
2323             ACTIONS => {
2324             'TYPE_INTEGER' => 149,
2325             'TYPE_FHREF' => 232,
2326             'WORD' => 152,
2327             'WORD_SCOPED' => 150
2328             },
2329             GOTOS => {
2330             'Type' => 231
2331             }
2332             },
2333             {#State 133
2334             DEFAULT => -131
2335             },
2336             {#State 134
2337             DEFAULT => -153
2338             },
2339             {#State 135
2340             ACTIONS => {
2341             'OP24_LOGICAL_OR_XOR' => -149,
2342             'OP17_LIST_RANGE' => -149,
2343             'OP12_COMPARE_EQ_NE' => -149,
2344             ";" => 233,
2345             'OP11_COMPARE_LT_GT' => -149,
2346             'OP07_MATH_MULT_DIV_MOD' => -149,
2347             'OP09_BITWISE_SHIFT' => -149,
2348             'OP07_STRING_REPEAT' => -149,
2349             'OP14_BITWISE_OR_XOR' => -149,
2350             'OP15_LOGICAL_AND' => -149,
2351             'OP23_LOGICAL_AND' => -149,
2352             'OP04_MATH_POW' => -149,
2353             'OP08_MATH_ADD_SUB' => -149,
2354             'OP08_STRING_CAT' => -149,
2355             'OP16_LOGICAL_OR' => -149,
2356             'OP13_BITWISE_AND' => -149,
2357             'OP06_REGEX_BIND' => -149,
2358             'OP18_TERNARY' => -149
2359             }
2360             },
2361             {#State 136
2362             ACTIONS => {
2363             'LPAREN' => 234
2364             }
2365             },
2366             {#State 137
2367             DEFAULT => -92
2368             },
2369             {#State 138
2370             DEFAULT => -135
2371             },
2372             {#State 139
2373             DEFAULT => -154
2374             },
2375             {#State 140
2376             ACTIONS => {
2377             'OP02_METHOD_THINARROW_NEW' => 236,
2378             'LPAREN' => 235
2379             }
2380             },
2381             {#State 141
2382             ACTIONS => {
2383             'OP14_BITWISE_OR_XOR' => 237,
2384             'OP15_LOGICAL_AND' => 248,
2385             'OP07_STRING_REPEAT' => 238,
2386             'OP12_COMPARE_EQ_NE' => 239,
2387             'OP07_MATH_MULT_DIV_MOD' => 240,
2388             'OP09_BITWISE_SHIFT' => 250,
2389             'OP11_COMPARE_LT_GT' => 249,
2390             'OP17_LIST_RANGE' => 241,
2391             'OP24_LOGICAL_OR_XOR' => 242,
2392             'OP06_REGEX_BIND' => 251,
2393             'OP13_BITWISE_AND' => 243,
2394             'OP18_TERNARY' => 252,
2395             'OP16_LOGICAL_OR' => 253,
2396             'OP08_STRING_CAT' => 245,
2397             'OP08_MATH_ADD_SUB' => 244,
2398             'OP23_LOGICAL_AND' => 246,
2399             'OP04_MATH_POW' => 247
2400             }
2401             },
2402             {#State 142
2403             DEFAULT => -156
2404             },
2405             {#State 143
2406             DEFAULT => -247
2407             },
2408             {#State 144
2409             ACTIONS => {
2410             'COLON' => 254
2411             }
2412             },
2413             {#State 145
2414             ACTIONS => {
2415             'OP09_BITWISE_SHIFT' => -152,
2416             'OP11_COMPARE_LT_GT' => -152,
2417             'OP07_MATH_MULT_DIV_MOD' => -152,
2418             'OP12_COMPARE_EQ_NE' => -152,
2419             'OP14_BITWISE_OR_XOR' => -152,
2420             'OP15_LOGICAL_AND' => -152,
2421             'OP07_STRING_REPEAT' => -152,
2422             'OP24_LOGICAL_OR_XOR' => -152,
2423             'OP17_LIST_RANGE' => -152,
2424             'OP19_VARIABLE_ASSIGN_BY' => 257,
2425             'OP19_VARIABLE_ASSIGN' => 256,
2426             'OP16_LOGICAL_OR' => -152,
2427             ")" => -152,
2428             'OP18_TERNARY' => -152,
2429             'OP06_REGEX_BIND' => -152,
2430             'OP13_BITWISE_AND' => -152,
2431             'OP04_MATH_POW' => -152,
2432             'OP02_METHOD_THINARROW' => 258,
2433             'OP23_LOGICAL_AND' => -152,
2434             'OP03_MATH_INC_DEC' => 255,
2435             'OP08_STRING_CAT' => -152,
2436             'OP08_MATH_ADD_SUB' => -152
2437             }
2438             },
2439             {#State 146
2440             ACTIONS => {
2441             "use constant" => 57,
2442             "our hashref \$properties" => 259
2443             },
2444             GOTOS => {
2445             'Constant' => 261,
2446             'Properties' => 260
2447             }
2448             },
2449             {#State 147
2450             DEFAULT => -66
2451             },
2452             {#State 148
2453             ACTIONS => {
2454             ";" => 262
2455             }
2456             },
2457             {#State 149
2458             DEFAULT => -236
2459             },
2460             {#State 150
2461             DEFAULT => -235
2462             },
2463             {#State 151
2464             ACTIONS => {
2465             "\$TYPED_" => 263
2466             }
2467             },
2468             {#State 152
2469             DEFAULT => -234
2470             },
2471             {#State 153
2472             ACTIONS => {
2473             'TYPE_INTEGER' => 149,
2474             'WORD' => 152,
2475             'WORD_SCOPED' => 150
2476             },
2477             GOTOS => {
2478             'Type' => 264
2479             }
2480             },
2481             {#State 154
2482             ACTIONS => {
2483             'TYPE_FHREF' => 265
2484             }
2485             },
2486             {#State 155
2487             DEFAULT => -97
2488             },
2489             {#State 156
2490             ACTIONS => {
2491             ";" => 266
2492             }
2493             },
2494             {#State 157
2495             DEFAULT => -233
2496             },
2497             {#State 158
2498             ACTIONS => {
2499             'OP21_LIST_COMMA' => 267
2500             }
2501             },
2502             {#State 159
2503             DEFAULT => -149
2504             },
2505             {#State 160
2506             ACTIONS => {
2507             'WORD_SCOPED' => 150,
2508             'WORD' => 152,
2509             'TYPE_INTEGER' => 149
2510             },
2511             GOTOS => {
2512             'Type' => 268
2513             }
2514             },
2515             {#State 161
2516             ACTIONS => {
2517             'LPAREN' => 227
2518             }
2519             },
2520             {#State 162
2521             ACTIONS => {
2522             'OP04_MATH_POW' => -94,
2523             'OP23_LOGICAL_AND' => -94,
2524             'OP08_MATH_ADD_SUB' => -94,
2525             'OP08_STRING_CAT' => -94,
2526             'OP16_LOGICAL_OR' => -94,
2527             ")" => -94,
2528             'OP18_TERNARY' => -94,
2529             'OP06_REGEX_BIND' => -94,
2530             'OP13_BITWISE_AND' => -94,
2531             'OP24_LOGICAL_OR_XOR' => -94,
2532             'OP17_LIST_RANGE' => -94,
2533             ";" => -94,
2534             'OP07_MATH_MULT_DIV_MOD' => -94,
2535             'OP09_BITWISE_SHIFT' => -94,
2536             'OP11_COMPARE_LT_GT' => -94,
2537             'OP12_COMPARE_EQ_NE' => -94,
2538             'OP21_LIST_COMMA' => -205,
2539             'OP07_STRING_REPEAT' => -94,
2540             'OP14_BITWISE_OR_XOR' => -94,
2541             'OP15_LOGICAL_AND' => -94
2542             }
2543             },
2544             {#State 163
2545             ACTIONS => {
2546             'LBRACE' => 100,
2547             'OP05_MATH_NEG_LPAREN' => 124,
2548             'LBRACKET' => 125,
2549             'WORD_UPPERCASE' => 161,
2550             'LPAREN' => 130,
2551             "\@{" => 99,
2552             'WORD' => 24,
2553             'LITERAL_NUMBER' => 98,
2554             'OP05_BITWISE_NEG_LPAREN' => 122,
2555             'OP01_NAMED' => 165,
2556             'LITERAL_STRING' => 123,
2557             'OP05_LOGICAL_NEG' => 120,
2558             'OP01_OPEN' => 92,
2559             'OP01_CLOSE' => 93,
2560             'OP03_MATH_INC_DEC' => 115,
2561             "%{" => 114,
2562             'CONSTANT_CALL_SCOPED' => 116,
2563             'SELF' => 143,
2564             'OP22_LOGICAL_NEG' => 110,
2565             'WORD_SCOPED' => 25,
2566             'OP22_LOGICAL_NEG_LPAREN' => 106,
2567             'OP10_NAMED_UNARY' => 109,
2568             "undef" => 104,
2569             'VARIABLE_SYMBOL' => 103
2570             },
2571             GOTOS => {
2572             'HashDereference' => 142,
2573             'VariableSymbolOrSelf' => 108,
2574             'SubExpression' => 269,
2575             'WordScoped' => 140,
2576             'ArrayDereference' => 139,
2577             'Expression' => 159,
2578             'ArrayReference' => 134,
2579             'Variable' => 164,
2580             'HashReference' => 126,
2581             'Literal' => 128,
2582             'Operator' => 111
2583             }
2584             },
2585             {#State 164
2586             ACTIONS => {
2587             ")" => -152,
2588             'OP16_LOGICAL_OR' => -152,
2589             'OP13_BITWISE_AND' => -152,
2590             'OP06_REGEX_BIND' => -152,
2591             'OP18_TERNARY' => -152,
2592             'OP23_LOGICAL_AND' => -152,
2593             'OP03_MATH_INC_DEC' => 255,
2594             'OP02_METHOD_THINARROW' => 258,
2595             'OP04_MATH_POW' => -152,
2596             'OP08_MATH_ADD_SUB' => -152,
2597             'OP08_STRING_CAT' => -152,
2598             "]" => -152,
2599             'OP12_COMPARE_EQ_NE' => -152,
2600             'OP21_LIST_COMMA' => -152,
2601             ";" => -152,
2602             'OP11_COMPARE_LT_GT' => -152,
2603             'OP09_BITWISE_SHIFT' => -152,
2604             'OP07_MATH_MULT_DIV_MOD' => -152,
2605             'OP14_BITWISE_OR_XOR' => -152,
2606             'OP15_LOGICAL_AND' => -152,
2607             'OP07_STRING_REPEAT' => -152,
2608             'OP24_LOGICAL_OR_XOR' => -152,
2609             'OP17_LIST_RANGE' => -152,
2610             "}" => -152
2611             }
2612             },
2613             {#State 165
2614             ACTIONS => {
2615             'WORD' => 24,
2616             'LITERAL_NUMBER' => 98,
2617             'OP01_NAMED' => 165,
2618             'LITERAL_STRING' => 123,
2619             'OP05_BITWISE_NEG_LPAREN' => 122,
2620             'OP05_LOGICAL_NEG' => 120,
2621             'OP01_CLOSE' => 93,
2622             'OP01_OPEN' => 92,
2623             'LBRACE' => 100,
2624             'OP05_MATH_NEG_LPAREN' => 124,
2625             'LBRACKET' => 125,
2626             "\@{" => 99,
2627             'WORD_UPPERCASE' => 161,
2628             'LPAREN' => 130,
2629             'OP22_LOGICAL_NEG_LPAREN' => 106,
2630             'WORD_SCOPED' => 25,
2631             'OP10_NAMED_UNARY' => 109,
2632             'VARIABLE_SYMBOL' => 103,
2633             "undef" => 104,
2634             "%{" => 114,
2635             'CONSTANT_CALL_SCOPED' => 116,
2636             'OP03_MATH_INC_DEC' => 115,
2637             'SELF' => 143,
2638             'OP22_LOGICAL_NEG' => 110
2639             },
2640             GOTOS => {
2641             'ArrayDereference' => 139,
2642             'WordScoped' => 140,
2643             'VariableSymbolOrSelf' => 108,
2644             'HashDereference' => 142,
2645             'SubExpression' => 270,
2646             'Operator' => 111,
2647             'Literal' => 128,
2648             'HashReference' => 126,
2649             'Variable' => 164,
2650             'ArrayReference' => 134,
2651             'Expression' => 159
2652             }
2653             },
2654             {#State 166
2655             DEFAULT => -208
2656             },
2657             {#State 167
2658             DEFAULT => -207
2659             },
2660             {#State 168
2661             ACTIONS => {
2662             "}" => 271
2663             }
2664             },
2665             {#State 169
2666             DEFAULT => -212
2667             },
2668             {#State 170
2669             ACTIONS => {
2670             'LBRACKET' => 125
2671             },
2672             GOTOS => {
2673             'ArrayReference' => 272
2674             }
2675             },
2676             {#State 171
2677             DEFAULT => -266
2678             },
2679             {#State 172
2680             DEFAULT => -261
2681             },
2682             {#State 173
2683             DEFAULT => -272
2684             },
2685             {#State 174
2686             DEFAULT => -265
2687             },
2688             {#State 175
2689             DEFAULT => -226
2690             },
2691             {#State 176
2692             DEFAULT => -244
2693             },
2694             {#State 177
2695             DEFAULT => -256
2696             },
2697             {#State 178
2698             DEFAULT => -259
2699             },
2700             {#State 179
2701             DEFAULT => -219
2702             },
2703             {#State 180
2704             DEFAULT => -264
2705             },
2706             {#State 181
2707             DEFAULT => -257
2708             },
2709             {#State 182
2710             DEFAULT => -243
2711             },
2712             {#State 183
2713             ACTIONS => {
2714             'OP20_HASH_FATARROW' => 273
2715             }
2716             },
2717             {#State 184
2718             DEFAULT => -269
2719             },
2720             {#State 185
2721             DEFAULT => -268
2722             },
2723             {#State 186
2724             DEFAULT => -220
2725             },
2726             {#State 187
2727             DEFAULT => -260
2728             },
2729             {#State 188
2730             DEFAULT => -262
2731             },
2732             {#State 189
2733             DEFAULT => -267
2734             },
2735             {#State 190
2736             DEFAULT => -224,
2737             GOTOS => {
2738             'STAR-57' => 274
2739             }
2740             },
2741             {#State 191
2742             DEFAULT => -271
2743             },
2744             {#State 192
2745             DEFAULT => -270
2746             },
2747             {#State 193
2748             DEFAULT => -263
2749             },
2750             {#State 194
2751             DEFAULT => -245
2752             },
2753             {#State 195
2754             DEFAULT => -258
2755             },
2756             {#State 196
2757             ACTIONS => {
2758             'LPAREN' => 275,
2759             'LPAREN_MY' => 276
2760             }
2761             },
2762             {#State 197
2763             ACTIONS => {
2764             'LPAREN_MY' => 277,
2765             'MY' => 278
2766             }
2767             },
2768             {#State 198
2769             ACTIONS => {
2770             'MY' => 279
2771             }
2772             },
2773             {#State 199
2774             DEFAULT => -180
2775             },
2776             {#State 200
2777             DEFAULT => -178
2778             },
2779             {#State 201
2780             DEFAULT => -179
2781             },
2782             {#State 202
2783             DEFAULT => -167
2784             },
2785             {#State 203
2786             DEFAULT => -125
2787             },
2788             {#State 204
2789             DEFAULT => -124
2790             },
2791             {#State 205
2792             ACTIONS => {
2793             'ARGV' => 166,
2794             "%{" => 114,
2795             'CONSTANT_CALL_SCOPED' => 116,
2796             'OP03_MATH_INC_DEC' => 115,
2797             'OP22_LOGICAL_NEG' => 110,
2798             'OP01_QW' => 167,
2799             'SELF' => 143,
2800             'OP10_NAMED_UNARY' => 109,
2801             'OP22_LOGICAL_NEG_LPAREN' => 106,
2802             'WORD_SCOPED' => 25,
2803             "undef" => 104,
2804             'VARIABLE_SYMBOL' => 103,
2805             'LBRACE' => 100,
2806             'MY' => 160,
2807             'WORD_UPPERCASE' => 161,
2808             'LPAREN' => 130,
2809             "\@{" => 99,
2810             'LBRACKET' => 125,
2811             'OP05_MATH_NEG_LPAREN' => 124,
2812             'LITERAL_NUMBER' => 98,
2813             'OP05_BITWISE_NEG_LPAREN' => 122,
2814             'LITERAL_STRING' => 123,
2815             'OP01_NAMED' => 165,
2816             'WORD' => 24,
2817             'OP01_OPEN' => 92,
2818             'OP05_LOGICAL_NEG' => 120,
2819             'OP01_CLOSE' => 93
2820             },
2821             GOTOS => {
2822             'WordScoped' => 140,
2823             'ArrayDereference' => 139,
2824             'TypeInner' => 163,
2825             'SubExpression' => 210,
2826             'ListElement' => 209,
2827             'HashDereference' => 142,
2828             'VariableSymbolOrSelf' => 108,
2829             'HashReference' => 126,
2830             'ListElements' => 280,
2831             'Literal' => 128,
2832             'Operator' => 111,
2833             'Expression' => 159,
2834             'ArrayReference' => 134,
2835             'Variable' => 164
2836             }
2837             },
2838             {#State 206
2839             ACTIONS => {
2840             'LBRACKET' => 125,
2841             'OP05_MATH_NEG_LPAREN' => 124,
2842             'LPAREN' => 130,
2843             'WORD_UPPERCASE' => 161,
2844             "\@{" => 99,
2845             'MY' => 160,
2846             'LBRACE' => 100,
2847             'OP05_LOGICAL_NEG' => 120,
2848             'OP01_CLOSE' => 93,
2849             'OP01_OPEN' => 92,
2850             'WORD' => 24,
2851             'LITERAL_STRING' => 123,
2852             'OP01_NAMED' => 165,
2853             'OP05_BITWISE_NEG_LPAREN' => 122,
2854             'LITERAL_NUMBER' => 98,
2855             'SELF' => 143,
2856             'OP01_QW' => 167,
2857             'OP22_LOGICAL_NEG' => 110,
2858             'OP03_MATH_INC_DEC' => 115,
2859             "%{" => 114,
2860             'CONSTANT_CALL_SCOPED' => 116,
2861             'ARGV' => 166,
2862             'VARIABLE_SYMBOL' => 103,
2863             "undef" => 104,
2864             'OP22_LOGICAL_NEG_LPAREN' => 106,
2865             'WORD_SCOPED' => 25,
2866             'OP10_NAMED_UNARY' => 109
2867             },
2868             GOTOS => {
2869             'Operator' => 111,
2870             'Literal' => 128,
2871             'ListElements' => 281,
2872             'HashReference' => 126,
2873             'Variable' => 164,
2874             'Expression' => 159,
2875             'ArrayReference' => 134,
2876             'ArrayDereference' => 139,
2877             'WordScoped' => 140,
2878             'TypeInner' => 163,
2879             'HashDereference' => 142,
2880             'ListElement' => 209,
2881             'VariableSymbolOrSelf' => 108,
2882             'SubExpression' => 210
2883             }
2884             },
2885             {#State 207
2886             ACTIONS => {
2887             'OP24_LOGICAL_OR_XOR' => 242,
2888             'OP17_LIST_RANGE' => 241,
2889             'OP12_COMPARE_EQ_NE' => 239,
2890             'OP11_COMPARE_LT_GT' => 249,
2891             'OP09_BITWISE_SHIFT' => 250,
2892             'OP07_MATH_MULT_DIV_MOD' => 240,
2893             'OP15_LOGICAL_AND' => 248,
2894             'OP14_BITWISE_OR_XOR' => 237,
2895             'OP07_STRING_REPEAT' => 238,
2896             'OP23_LOGICAL_AND' => 246,
2897             'OP04_MATH_POW' => 247,
2898             'OP08_STRING_CAT' => 245,
2899             'OP08_MATH_ADD_SUB' => 244,
2900             ")" => 282,
2901             'OP16_LOGICAL_OR' => 253,
2902             'OP13_BITWISE_AND' => 243,
2903             'OP06_REGEX_BIND' => 251,
2904             'OP18_TERNARY' => 252
2905             }
2906             },
2907             {#State 208
2908             ACTIONS => {
2909             ";" => 283
2910             }
2911             },
2912             {#State 209
2913             DEFAULT => -203,
2914             GOTOS => {
2915             'STAR-52' => 284
2916             }
2917             },
2918             {#State 210
2919             ACTIONS => {
2920             'OP24_LOGICAL_OR_XOR' => 242,
2921             'OP17_LIST_RANGE' => 241,
2922             'OP21_LIST_COMMA' => -205,
2923             'OP12_COMPARE_EQ_NE' => 239,
2924             'OP07_MATH_MULT_DIV_MOD' => 240,
2925             'OP11_COMPARE_LT_GT' => 249,
2926             'OP09_BITWISE_SHIFT' => 250,
2927             ";" => -205,
2928             'OP14_BITWISE_OR_XOR' => 237,
2929             'OP07_STRING_REPEAT' => 238,
2930             'OP15_LOGICAL_AND' => 248,
2931             'OP23_LOGICAL_AND' => 246,
2932             'OP04_MATH_POW' => 247,
2933             'OP08_STRING_CAT' => 245,
2934             "]" => -205,
2935             'OP08_MATH_ADD_SUB' => 244,
2936             ")" => -205,
2937             'OP16_LOGICAL_OR' => 253,
2938             'OP06_REGEX_BIND' => 251,
2939             'OP13_BITWISE_AND' => 243,
2940             'OP18_TERNARY' => 252
2941             }
2942             },
2943             {#State 211
2944             ACTIONS => {
2945             'OP15_LOGICAL_AND' => -191,
2946             'OP14_BITWISE_OR_XOR' => -191,
2947             'OP07_STRING_REPEAT' => -191,
2948             'OP02_HASH_THINARROW' => 285,
2949             'COLON' => -191,
2950             ";" => -191,
2951             'OP09_BITWISE_SHIFT' => -191,
2952             'OP11_COMPARE_LT_GT' => -191,
2953             'OP07_MATH_MULT_DIV_MOD' => -191,
2954             'OP12_COMPARE_EQ_NE' => -191,
2955             'OP21_LIST_COMMA' => -191,
2956             "}" => -191,
2957             'OP17_LIST_RANGE' => -191,
2958             'OP24_LOGICAL_OR_XOR' => -191,
2959             'OP18_TERNARY' => -191,
2960             'OP06_REGEX_BIND' => -191,
2961             'OP13_BITWISE_AND' => -191,
2962             'OP16_LOGICAL_OR' => -191,
2963             'OP19_VARIABLE_ASSIGN' => -191,
2964             'OP20_HASH_FATARROW' => -191,
2965             'OP19_VARIABLE_ASSIGN_BY' => -191,
2966             ")" => -191,
2967             'OP08_MATH_ADD_SUB' => -191,
2968             'OP02_ARRAY_THINARROW' => 286,
2969             'OP08_STRING_CAT' => -191,
2970             "]" => -191,
2971             'OP04_MATH_POW' => -191,
2972             'OP03_MATH_INC_DEC' => -191,
2973             'OP23_LOGICAL_AND' => -191,
2974             'OP02_METHOD_THINARROW' => -191
2975             },
2976             GOTOS => {
2977             'VariableRetrieval' => 287
2978             }
2979             },
2980             {#State 212
2981             ACTIONS => {
2982             'OP17_LIST_RANGE' => -110,
2983             "}" => -110,
2984             'OP24_LOGICAL_OR_XOR' => -110,
2985             'OP14_BITWISE_OR_XOR' => -110,
2986             'OP07_STRING_REPEAT' => 238,
2987             'OP15_LOGICAL_AND' => -110,
2988             'OP21_LIST_COMMA' => -110,
2989             'OP12_COMPARE_EQ_NE' => -110,
2990             'OP07_MATH_MULT_DIV_MOD' => 240,
2991             'OP11_COMPARE_LT_GT' => -110,
2992             'OP09_BITWISE_SHIFT' => 250,
2993             ";" => -110,
2994             "]" => -110,
2995             'OP08_STRING_CAT' => 245,
2996             'OP08_MATH_ADD_SUB' => 244,
2997             'OP23_LOGICAL_AND' => -110,
2998             'OP04_MATH_POW' => 247,
2999             'OP06_REGEX_BIND' => 251,
3000             'OP13_BITWISE_AND' => -110,
3001             'OP18_TERNARY' => -110,
3002             ")" => -110,
3003             'OP16_LOGICAL_OR' => -110
3004             }
3005             },
3006             {#State 213
3007             ACTIONS => {
3008             'OP17_LIST_RANGE' => 241,
3009             "}" => -121,
3010             'OP24_LOGICAL_OR_XOR' => -121,
3011             'OP15_LOGICAL_AND' => 248,
3012             'OP07_STRING_REPEAT' => 238,
3013             'OP14_BITWISE_OR_XOR' => 237,
3014             'OP21_LIST_COMMA' => -121,
3015             'OP12_COMPARE_EQ_NE' => 239,
3016             'OP09_BITWISE_SHIFT' => 250,
3017             'OP11_COMPARE_LT_GT' => 249,
3018             'OP07_MATH_MULT_DIV_MOD' => 240,
3019             ";" => -121,
3020             "]" => -121,
3021             'OP08_STRING_CAT' => 245,
3022             'OP08_MATH_ADD_SUB' => 244,
3023             'OP23_LOGICAL_AND' => -121,
3024             'OP04_MATH_POW' => 247,
3025             'OP06_REGEX_BIND' => 251,
3026             'OP13_BITWISE_AND' => 243,
3027             'OP18_TERNARY' => 252,
3028             ")" => -121,
3029             'OP16_LOGICAL_OR' => 253
3030             }
3031             },
3032             {#State 214
3033             DEFAULT => -127
3034             },
3035             {#State 215
3036             ACTIONS => {
3037             ")" => 288
3038             }
3039             },
3040             {#State 216
3041             ACTIONS => {
3042             "}" => 289
3043             }
3044             },
3045             {#State 217
3046             DEFAULT => -227
3047             },
3048             {#State 218
3049             ACTIONS => {
3050             'LBRACE' => 100
3051             },
3052             GOTOS => {
3053             'HashReference' => 290
3054             }
3055             },
3056             {#State 219
3057             DEFAULT => -98
3058             },
3059             {#State 220
3060             ACTIONS => {
3061             'OP13_BITWISE_AND' => -102,
3062             'OP06_REGEX_BIND' => -102,
3063             'OP18_TERNARY' => -102,
3064             ")" => -102,
3065             'OP16_LOGICAL_OR' => -102,
3066             "]" => -102,
3067             'OP08_STRING_CAT' => -102,
3068             'OP08_MATH_ADD_SUB' => -102,
3069             'OP23_LOGICAL_AND' => -102,
3070             'OP04_MATH_POW' => 247,
3071             'OP07_STRING_REPEAT' => -102,
3072             'OP15_LOGICAL_AND' => -102,
3073             'OP14_BITWISE_OR_XOR' => -102,
3074             'OP21_LIST_COMMA' => -102,
3075             'OP12_COMPARE_EQ_NE' => -102,
3076             'OP11_COMPARE_LT_GT' => -102,
3077             'OP07_MATH_MULT_DIV_MOD' => -102,
3078             'OP09_BITWISE_SHIFT' => -102,
3079             ";" => -102,
3080             'OP17_LIST_RANGE' => -102,
3081             "}" => -102,
3082             'OP24_LOGICAL_OR_XOR' => -102
3083             }
3084             },
3085             {#State 221
3086             DEFAULT => -170
3087             },
3088             {#State 222
3089             ACTIONS => {
3090             'OP08_MATH_ADD_SUB' => 244,
3091             'OP08_STRING_CAT' => 245,
3092             'OP23_LOGICAL_AND' => 246,
3093             'OP04_MATH_POW' => 247,
3094             'OP13_BITWISE_AND' => 243,
3095             'OP06_REGEX_BIND' => 251,
3096             'OP18_TERNARY' => 252,
3097             ")" => 291,
3098             'OP16_LOGICAL_OR' => 253,
3099             'OP17_LIST_RANGE' => 241,
3100             'OP24_LOGICAL_OR_XOR' => 242,
3101             'OP07_STRING_REPEAT' => 238,
3102             'OP15_LOGICAL_AND' => 248,
3103             'OP14_BITWISE_OR_XOR' => 237,
3104             'OP12_COMPARE_EQ_NE' => 239,
3105             'OP09_BITWISE_SHIFT' => 250,
3106             'OP11_COMPARE_LT_GT' => 249,
3107             'OP07_MATH_MULT_DIV_MOD' => 240
3108             }
3109             },
3110             {#State 223
3111             ACTIONS => {
3112             ")" => 292,
3113             'OP16_LOGICAL_OR' => 253,
3114             'OP13_BITWISE_AND' => 243,
3115             'OP06_REGEX_BIND' => 251,
3116             'OP18_TERNARY' => 252,
3117             'OP23_LOGICAL_AND' => 246,
3118             'OP04_MATH_POW' => 247,
3119             'OP08_STRING_CAT' => 245,
3120             'OP08_MATH_ADD_SUB' => 244,
3121             'OP12_COMPARE_EQ_NE' => 239,
3122             'OP09_BITWISE_SHIFT' => 250,
3123             'OP07_MATH_MULT_DIV_MOD' => 240,
3124             'OP11_COMPARE_LT_GT' => 249,
3125             'OP14_BITWISE_OR_XOR' => 237,
3126             'OP15_LOGICAL_AND' => 248,
3127             'OP07_STRING_REPEAT' => 238,
3128             'OP24_LOGICAL_OR_XOR' => 242,
3129             'OP17_LIST_RANGE' => 241
3130             }
3131             },
3132             {#State 224
3133             DEFAULT => -209
3134             },
3135             {#State 225
3136             ACTIONS => {
3137             "]" => 293
3138             }
3139             },
3140             {#State 226
3141             DEFAULT => -16
3142             },
3143             {#State 227
3144             ACTIONS => {
3145             ")" => 294
3146             }
3147             },
3148             {#State 228
3149             ACTIONS => {
3150             'FHREF_SYMBOL_BRACES' => 295
3151             }
3152             },
3153             {#State 229
3154             ACTIONS => {
3155             'ARGV' => 166,
3156             'OP03_MATH_INC_DEC' => 115,
3157             "%{" => 114,
3158             'CONSTANT_CALL_SCOPED' => 116,
3159             'OP22_LOGICAL_NEG' => 110,
3160             'OP01_QW' => 167,
3161             'SELF' => 143,
3162             'OP10_NAMED_UNARY' => 109,
3163             'WORD_SCOPED' => 25,
3164             'OP22_LOGICAL_NEG_LPAREN' => 106,
3165             'VARIABLE_SYMBOL' => 103,
3166             "undef" => 104,
3167             'LBRACE' => 100,
3168             'MY' => 160,
3169             'LPAREN' => 130,
3170             "\@{" => 99,
3171             'WORD_UPPERCASE' => 161,
3172             'LBRACKET' => 125,
3173             'OP05_MATH_NEG_LPAREN' => 124,
3174             'LITERAL_NUMBER' => 98,
3175             'OP01_NAMED' => 165,
3176             'LITERAL_STRING' => 123,
3177             'OP05_BITWISE_NEG_LPAREN' => 122,
3178             'WORD' => 24,
3179             'OP01_OPEN' => 92,
3180             'OP01_CLOSE' => 93,
3181             'OP05_LOGICAL_NEG' => 120
3182             },
3183             GOTOS => {
3184             'HashReference' => 126,
3185             'Literal' => 128,
3186             'Operator' => 111,
3187             'Expression' => 159,
3188             'ArrayReference' => 134,
3189             'Variable' => 164,
3190             'ArrayDereference' => 139,
3191             'WordScoped' => 140,
3192             'TypeInner' => 163,
3193             'SubExpression' => 162,
3194             'VariableSymbolOrSelf' => 108,
3195             'ListElement' => 296,
3196             'HashDereference' => 142
3197             }
3198             },
3199             {#State 230
3200             ACTIONS => {
3201             'OP07_STRING_REPEAT' => 238,
3202             'OP14_BITWISE_OR_XOR' => 237,
3203             'OP15_LOGICAL_AND' => 248,
3204             'OP11_COMPARE_LT_GT' => 249,
3205             'OP07_MATH_MULT_DIV_MOD' => 240,
3206             'OP09_BITWISE_SHIFT' => 250,
3207             'OP12_COMPARE_EQ_NE' => 239,
3208             'OP17_LIST_RANGE' => 241,
3209             'OP24_LOGICAL_OR_XOR' => 242,
3210             'OP18_TERNARY' => 252,
3211             'OP13_BITWISE_AND' => 243,
3212             'OP06_REGEX_BIND' => 251,
3213             'OP16_LOGICAL_OR' => 253,
3214             ")" => 297,
3215             'OP08_STRING_CAT' => 245,
3216             'OP08_MATH_ADD_SUB' => 244,
3217             'OP04_MATH_POW' => 247,
3218             'OP23_LOGICAL_AND' => 246
3219             }
3220             },
3221             {#State 231
3222             ACTIONS => {
3223             'VARIABLE_SYMBOL' => 298
3224             }
3225             },
3226             {#State 232
3227             ACTIONS => {
3228             'FHREF_SYMBOL' => 299
3229             }
3230             },
3231             {#State 233
3232             DEFAULT => -89
3233             },
3234             {#State 234
3235             ACTIONS => {
3236             'OP05_LOGICAL_NEG' => 120,
3237             'OP01_OPEN' => 92,
3238             'OP01_CLOSE' => 93,
3239             'WORD' => 24,
3240             'LITERAL_NUMBER' => 98,
3241             'OP05_BITWISE_NEG_LPAREN' => 122,
3242             'LITERAL_STRING' => 123,
3243             'OP01_NAMED' => 165,
3244             'OP05_MATH_NEG_LPAREN' => 124,
3245             'LBRACKET' => 125,
3246             'WORD_UPPERCASE' => 161,
3247             'LPAREN' => 130,
3248             "\@{" => 99,
3249             'LBRACE' => 100,
3250             'VARIABLE_SYMBOL' => 103,
3251             "undef" => 104,
3252             'WORD_SCOPED' => 25,
3253             'OP22_LOGICAL_NEG_LPAREN' => 106,
3254             'OP10_NAMED_UNARY' => 109,
3255             'SELF' => 143,
3256             'OP22_LOGICAL_NEG' => 110,
3257             'CONSTANT_CALL_SCOPED' => 116,
3258             'OP03_MATH_INC_DEC' => 115,
3259             "%{" => 114
3260             },
3261             GOTOS => {
3262             'HashReference' => 126,
3263             'Literal' => 128,
3264             'Operator' => 111,
3265             'ArrayReference' => 134,
3266             'Expression' => 159,
3267             'Variable' => 164,
3268             'ArrayDereference' => 139,
3269             'WordScoped' => 140,
3270             'SubExpression' => 300,
3271             'VariableSymbolOrSelf' => 108,
3272             'HashDereference' => 142
3273             }
3274             },
3275             {#State 235
3276             ACTIONS => {
3277             'ARGV' => 166,
3278             'OP03_MATH_INC_DEC' => 115,
3279             "%{" => 114,
3280             'CONSTANT_CALL_SCOPED' => 116,
3281             'OP22_LOGICAL_NEG' => 110,
3282             'OP01_QW' => 167,
3283             'SELF' => 143,
3284             'OP10_NAMED_UNARY' => 109,
3285             ")" => -138,
3286             'WORD_SCOPED' => 25,
3287             'OP22_LOGICAL_NEG_LPAREN' => 106,
3288             'VARIABLE_SYMBOL' => 103,
3289             "undef" => 104,
3290             'LBRACE' => 100,
3291             'MY' => 160,
3292             "\@{" => 99,
3293             'LPAREN' => 130,
3294             'WORD_UPPERCASE' => 161,
3295             'OP05_MATH_NEG_LPAREN' => 124,
3296             'LBRACKET' => 125,
3297             'LITERAL_NUMBER' => 98,
3298             'OP01_NAMED' => 165,
3299             'LITERAL_STRING' => 123,
3300             'OP05_BITWISE_NEG_LPAREN' => 122,
3301             'WORD' => 24,
3302             'OP01_OPEN' => 92,
3303             'OP05_LOGICAL_NEG' => 120,
3304             'OP01_CLOSE' => 93
3305             },
3306             GOTOS => {
3307             'OPTIONAL-40' => 302,
3308             'ListElements' => 301,
3309             'Operator' => 111,
3310             'Literal' => 128,
3311             'HashReference' => 126,
3312             'Variable' => 164,
3313             'Expression' => 159,
3314             'ArrayReference' => 134,
3315             'TypeInner' => 163,
3316             'WordScoped' => 140,
3317             'ArrayDereference' => 139,
3318             'VariableSymbolOrSelf' => 108,
3319             'ListElement' => 209,
3320             'HashDereference' => 142,
3321             'SubExpression' => 210
3322             }
3323             },
3324             {#State 236
3325             ACTIONS => {
3326             'LBRACE' => 100,
3327             ")" => -142
3328             },
3329             GOTOS => {
3330             'HashReference' => 304,
3331             'OPTIONAL-42' => 303
3332             }
3333             },
3334             {#State 237
3335             ACTIONS => {
3336             'VARIABLE_SYMBOL' => 103,
3337             "undef" => 104,
3338             'OP22_LOGICAL_NEG_LPAREN' => 106,
3339             'WORD_SCOPED' => 25,
3340             'OP10_NAMED_UNARY' => 109,
3341             'SELF' => 143,
3342             'OP22_LOGICAL_NEG' => 110,
3343             'CONSTANT_CALL_SCOPED' => 116,
3344             "%{" => 114,
3345             'OP03_MATH_INC_DEC' => 115,
3346             'OP01_OPEN' => 92,
3347             'OP05_LOGICAL_NEG' => 120,
3348             'OP01_CLOSE' => 93,
3349             'WORD' => 24,
3350             'LITERAL_NUMBER' => 98,
3351             'LITERAL_STRING' => 123,
3352             'OP05_BITWISE_NEG_LPAREN' => 122,
3353             'OP01_NAMED' => 165,
3354             'LBRACKET' => 125,
3355             'OP05_MATH_NEG_LPAREN' => 124,
3356             'WORD_UPPERCASE' => 161,
3357             "\@{" => 99,
3358             'LPAREN' => 130,
3359             'LBRACE' => 100
3360             },
3361             GOTOS => {
3362             'ArrayDereference' => 139,
3363             'WordScoped' => 140,
3364             'HashDereference' => 142,
3365             'VariableSymbolOrSelf' => 108,
3366             'SubExpression' => 305,
3367             'Operator' => 111,
3368             'Literal' => 128,
3369             'HashReference' => 126,
3370             'Variable' => 164,
3371             'Expression' => 159,
3372             'ArrayReference' => 134
3373             }
3374             },
3375             {#State 238
3376             ACTIONS => {
3377             'OP01_OPEN' => 92,
3378             'OP01_CLOSE' => 93,
3379             'OP05_LOGICAL_NEG' => 120,
3380             'WORD' => 24,
3381             'OP05_BITWISE_NEG_LPAREN' => 122,
3382             'OP01_NAMED' => 165,
3383             'LITERAL_STRING' => 123,
3384             'LITERAL_NUMBER' => 98,
3385             'OP05_MATH_NEG_LPAREN' => 124,
3386             'LBRACKET' => 125,
3387             'LPAREN' => 130,
3388             "\@{" => 99,
3389             'WORD_UPPERCASE' => 161,
3390             'LBRACE' => 100,
3391             'VARIABLE_SYMBOL' => 103,
3392             "undef" => 104,
3393             'OP22_LOGICAL_NEG_LPAREN' => 106,
3394             'WORD_SCOPED' => 25,
3395             'OP10_NAMED_UNARY' => 109,
3396             'SELF' => 143,
3397             'OP22_LOGICAL_NEG' => 110,
3398             'CONSTANT_CALL_SCOPED' => 116,
3399             'OP03_MATH_INC_DEC' => 115,
3400             "%{" => 114
3401             },
3402             GOTOS => {
3403             'WordScoped' => 140,
3404             'ArrayDereference' => 139,
3405             'SubExpression' => 306,
3406             'HashDereference' => 142,
3407             'VariableSymbolOrSelf' => 108,
3408             'Operator' => 111,
3409             'Literal' => 128,
3410             'HashReference' => 126,
3411             'Variable' => 164,
3412             'Expression' => 159,
3413             'ArrayReference' => 134
3414             }
3415             },
3416             {#State 239
3417             ACTIONS => {
3418             'OP05_MATH_NEG_LPAREN' => 124,
3419             'LBRACKET' => 125,
3420             'WORD_UPPERCASE' => 161,
3421             "\@{" => 99,
3422             'LPAREN' => 130,
3423             'LBRACE' => 100,
3424             'OP01_OPEN' => 92,
3425             'OP05_LOGICAL_NEG' => 120,
3426             'OP01_CLOSE' => 93,
3427             'WORD' => 24,
3428             'LITERAL_NUMBER' => 98,
3429             'OP05_BITWISE_NEG_LPAREN' => 122,
3430             'LITERAL_STRING' => 123,
3431             'OP01_NAMED' => 165,
3432             'SELF' => 143,
3433             'OP22_LOGICAL_NEG' => 110,
3434             'CONSTANT_CALL_SCOPED' => 116,
3435             "%{" => 114,
3436             'OP03_MATH_INC_DEC' => 115,
3437             "undef" => 104,
3438             'VARIABLE_SYMBOL' => 103,
3439             'OP22_LOGICAL_NEG_LPAREN' => 106,
3440             'WORD_SCOPED' => 25,
3441             'OP10_NAMED_UNARY' => 109
3442             },
3443             GOTOS => {
3444             'ArrayReference' => 134,
3445             'Expression' => 159,
3446             'Variable' => 164,
3447             'HashReference' => 126,
3448             'Operator' => 111,
3449             'Literal' => 128,
3450             'SubExpression' => 307,
3451             'HashDereference' => 142,
3452             'VariableSymbolOrSelf' => 108,
3453             'WordScoped' => 140,
3454             'ArrayDereference' => 139
3455             }
3456             },
3457             {#State 240
3458             ACTIONS => {
3459             'OP22_LOGICAL_NEG_LPAREN' => 106,
3460             'WORD_SCOPED' => 25,
3461             'OP10_NAMED_UNARY' => 109,
3462             'VARIABLE_SYMBOL' => 103,
3463             "undef" => 104,
3464             "%{" => 114,
3465             'OP03_MATH_INC_DEC' => 115,
3466             'CONSTANT_CALL_SCOPED' => 116,
3467             'SELF' => 143,
3468             'OP22_LOGICAL_NEG' => 110,
3469             'WORD' => 24,
3470             'LITERAL_NUMBER' => 98,
3471             'OP01_NAMED' => 165,
3472             'OP05_BITWISE_NEG_LPAREN' => 122,
3473             'LITERAL_STRING' => 123,
3474             'OP05_LOGICAL_NEG' => 120,
3475             'OP01_OPEN' => 92,
3476             'OP01_CLOSE' => 93,
3477             'LBRACE' => 100,
3478             'LBRACKET' => 125,
3479             'OP05_MATH_NEG_LPAREN' => 124,
3480             'WORD_UPPERCASE' => 161,
3481             "\@{" => 99,
3482             'LPAREN' => 130
3483             },
3484             GOTOS => {
3485             'Operator' => 111,
3486             'Literal' => 128,
3487             'HashReference' => 126,
3488             'Variable' => 164,
3489             'Expression' => 159,
3490             'ArrayReference' => 134,
3491             'WordScoped' => 140,
3492             'ArrayDereference' => 139,
3493             'SubExpression' => 308,
3494             'VariableSymbolOrSelf' => 108,
3495             'HashDereference' => 142
3496             }
3497             },
3498             {#State 241
3499             ACTIONS => {
3500             "%{" => 114,
3501             'OP03_MATH_INC_DEC' => 115,
3502             'CONSTANT_CALL_SCOPED' => 116,
3503             'SELF' => 143,
3504             'OP22_LOGICAL_NEG' => 110,
3505             'OP22_LOGICAL_NEG_LPAREN' => 106,
3506             'WORD_SCOPED' => 25,
3507             'OP10_NAMED_UNARY' => 109,
3508             'VARIABLE_SYMBOL' => 103,
3509             "undef" => 104,
3510             'LBRACE' => 100,
3511             'LBRACKET' => 125,
3512             'OP05_MATH_NEG_LPAREN' => 124,
3513             "\@{" => 99,
3514             'LPAREN' => 130,
3515             'WORD_UPPERCASE' => 161,
3516             'WORD' => 24,
3517             'LITERAL_NUMBER' => 98,
3518             'OP01_NAMED' => 165,
3519             'LITERAL_STRING' => 123,
3520             'OP05_BITWISE_NEG_LPAREN' => 122,
3521             'OP01_CLOSE' => 93,
3522             'OP01_OPEN' => 92,
3523             'OP05_LOGICAL_NEG' => 120
3524             },
3525             GOTOS => {
3526             'ArrayDereference' => 139,
3527             'WordScoped' => 140,
3528             'HashDereference' => 142,
3529             'VariableSymbolOrSelf' => 108,
3530             'SubExpression' => 309,
3531             'HashReference' => 126,
3532             'Operator' => 111,
3533             'Literal' => 128,
3534             'Expression' => 159,
3535             'ArrayReference' => 134,
3536             'Variable' => 164
3537             }
3538             },
3539             {#State 242
3540             ACTIONS => {
3541             'LBRACE' => 100,
3542             'WORD_UPPERCASE' => 161,
3543             "\@{" => 99,
3544             'LPAREN' => 130,
3545             'OP05_MATH_NEG_LPAREN' => 124,
3546             'LBRACKET' => 125,
3547             'LITERAL_NUMBER' => 98,
3548             'OP01_NAMED' => 165,
3549             'LITERAL_STRING' => 123,
3550             'OP05_BITWISE_NEG_LPAREN' => 122,
3551             'WORD' => 24,
3552             'OP01_OPEN' => 92,
3553             'OP05_LOGICAL_NEG' => 120,
3554             'OP01_CLOSE' => 93,
3555             'OP03_MATH_INC_DEC' => 115,
3556             'CONSTANT_CALL_SCOPED' => 116,
3557             "%{" => 114,
3558             'OP22_LOGICAL_NEG' => 110,
3559             'SELF' => 143,
3560             'OP10_NAMED_UNARY' => 109,
3561             'OP22_LOGICAL_NEG_LPAREN' => 106,
3562             'WORD_SCOPED' => 25,
3563             "undef" => 104,
3564             'VARIABLE_SYMBOL' => 103
3565             },
3566             GOTOS => {
3567             'WordScoped' => 140,
3568             'ArrayDereference' => 139,
3569             'VariableSymbolOrSelf' => 108,
3570             'HashDereference' => 142,
3571             'SubExpression' => 310,
3572             'HashReference' => 126,
3573             'Operator' => 111,
3574             'Literal' => 128,
3575             'ArrayReference' => 134,
3576             'Expression' => 159,
3577             'Variable' => 164
3578             }
3579             },
3580             {#State 243
3581             ACTIONS => {
3582             'VARIABLE_SYMBOL' => 103,
3583             "undef" => 104,
3584             'OP10_NAMED_UNARY' => 109,
3585             'OP22_LOGICAL_NEG_LPAREN' => 106,
3586             'WORD_SCOPED' => 25,
3587             'OP22_LOGICAL_NEG' => 110,
3588             'SELF' => 143,
3589             "%{" => 114,
3590             'OP03_MATH_INC_DEC' => 115,
3591             'CONSTANT_CALL_SCOPED' => 116,
3592             'OP01_OPEN' => 92,
3593             'OP05_LOGICAL_NEG' => 120,
3594             'OP01_CLOSE' => 93,
3595             'LITERAL_STRING' => 123,
3596             'OP05_BITWISE_NEG_LPAREN' => 122,
3597             'OP01_NAMED' => 165,
3598             'LITERAL_NUMBER' => 98,
3599             'WORD' => 24,
3600             "\@{" => 99,
3601             'WORD_UPPERCASE' => 161,
3602             'LPAREN' => 130,
3603             'LBRACKET' => 125,
3604             'OP05_MATH_NEG_LPAREN' => 124,
3605             'LBRACE' => 100
3606             },
3607             GOTOS => {
3608             'Variable' => 164,
3609             'Expression' => 159,
3610             'ArrayReference' => 134,
3611             'Operator' => 111,
3612             'Literal' => 128,
3613             'HashReference' => 126,
3614             'HashDereference' => 142,
3615             'VariableSymbolOrSelf' => 108,
3616             'SubExpression' => 311,
3617             'ArrayDereference' => 139,
3618             'WordScoped' => 140
3619             }
3620             },
3621             {#State 244
3622             ACTIONS => {
3623             'LBRACKET' => 125,
3624             'OP05_MATH_NEG_LPAREN' => 124,
3625             'LPAREN' => 130,
3626             'WORD_UPPERCASE' => 161,
3627             "\@{" => 99,
3628             'LBRACE' => 100,
3629             'OP05_LOGICAL_NEG' => 120,
3630             'OP01_OPEN' => 92,
3631             'OP01_CLOSE' => 93,
3632             'WORD' => 24,
3633             'LITERAL_STRING' => 123,
3634             'OP01_NAMED' => 165,
3635             'OP05_BITWISE_NEG_LPAREN' => 122,
3636             'LITERAL_NUMBER' => 98,
3637             'SELF' => 143,
3638             'OP22_LOGICAL_NEG' => 110,
3639             "%{" => 114,
3640             'OP03_MATH_INC_DEC' => 115,
3641             'CONSTANT_CALL_SCOPED' => 116,
3642             "undef" => 104,
3643             'VARIABLE_SYMBOL' => 103,
3644             'WORD_SCOPED' => 25,
3645             'OP22_LOGICAL_NEG_LPAREN' => 106,
3646             'OP10_NAMED_UNARY' => 109
3647             },
3648             GOTOS => {
3649             'Variable' => 164,
3650             'ArrayReference' => 134,
3651             'Expression' => 159,
3652             'Operator' => 111,
3653             'Literal' => 128,
3654             'HashReference' => 126,
3655             'HashDereference' => 142,
3656             'VariableSymbolOrSelf' => 108,
3657             'SubExpression' => 312,
3658             'WordScoped' => 140,
3659             'ArrayDereference' => 139
3660             }
3661             },
3662             {#State 245
3663             ACTIONS => {
3664             'OP22_LOGICAL_NEG_LPAREN' => 106,
3665             'WORD_SCOPED' => 25,
3666             'OP10_NAMED_UNARY' => 109,
3667             "undef" => 104,
3668             'VARIABLE_SYMBOL' => 103,
3669             'CONSTANT_CALL_SCOPED' => 116,
3670             "%{" => 114,
3671             'OP03_MATH_INC_DEC' => 115,
3672             'SELF' => 143,
3673             'OP22_LOGICAL_NEG' => 110,
3674             'WORD' => 24,
3675             'LITERAL_NUMBER' => 98,
3676             'LITERAL_STRING' => 123,
3677             'OP05_BITWISE_NEG_LPAREN' => 122,
3678             'OP01_NAMED' => 165,
3679             'OP05_LOGICAL_NEG' => 120,
3680             'OP01_OPEN' => 92,
3681             'OP01_CLOSE' => 93,
3682             'LBRACE' => 100,
3683             'OP05_MATH_NEG_LPAREN' => 124,
3684             'LBRACKET' => 125,
3685             'WORD_UPPERCASE' => 161,
3686             'LPAREN' => 130,
3687             "\@{" => 99
3688             },
3689             GOTOS => {
3690             'HashReference' => 126,
3691             'Operator' => 111,
3692             'Literal' => 128,
3693             'ArrayReference' => 134,
3694             'Expression' => 159,
3695             'Variable' => 164,
3696             'WordScoped' => 140,
3697             'ArrayDereference' => 139,
3698             'VariableSymbolOrSelf' => 108,
3699             'HashDereference' => 142,
3700             'SubExpression' => 313
3701             }
3702             },
3703             {#State 246
3704             ACTIONS => {
3705             'OP03_MATH_INC_DEC' => 115,
3706             "%{" => 114,
3707             'CONSTANT_CALL_SCOPED' => 116,
3708             'SELF' => 143,
3709             'OP22_LOGICAL_NEG' => 110,
3710             'OP22_LOGICAL_NEG_LPAREN' => 106,
3711             'WORD_SCOPED' => 25,
3712             'OP10_NAMED_UNARY' => 109,
3713             "undef" => 104,
3714             'VARIABLE_SYMBOL' => 103,
3715             'LBRACE' => 100,
3716             'OP05_MATH_NEG_LPAREN' => 124,
3717             'LBRACKET' => 125,
3718             'WORD_UPPERCASE' => 161,
3719             "\@{" => 99,
3720             'LPAREN' => 130,
3721             'WORD' => 24,
3722             'LITERAL_NUMBER' => 98,
3723             'OP05_BITWISE_NEG_LPAREN' => 122,
3724             'OP01_NAMED' => 165,
3725             'LITERAL_STRING' => 123,
3726             'OP05_LOGICAL_NEG' => 120,
3727             'OP01_CLOSE' => 93,
3728             'OP01_OPEN' => 92
3729             },
3730             GOTOS => {
3731             'HashReference' => 126,
3732             'Operator' => 111,
3733             'Literal' => 128,
3734             'Expression' => 159,
3735             'ArrayReference' => 134,
3736             'Variable' => 164,
3737             'WordScoped' => 140,
3738             'ArrayDereference' => 139,
3739             'SubExpression' => 314,
3740             'HashDereference' => 142,
3741             'VariableSymbolOrSelf' => 108
3742             }
3743             },
3744             {#State 247
3745             ACTIONS => {
3746             'LITERAL_NUMBER' => 98,
3747             'OP01_NAMED' => 165,
3748             'LITERAL_STRING' => 123,
3749             'OP05_BITWISE_NEG_LPAREN' => 122,
3750             'WORD' => 24,
3751             'OP05_LOGICAL_NEG' => 120,
3752             'OP01_CLOSE' => 93,
3753             'OP01_OPEN' => 92,
3754             'LBRACE' => 100,
3755             'WORD_UPPERCASE' => 161,
3756             'LPAREN' => 130,
3757             "\@{" => 99,
3758             'OP05_MATH_NEG_LPAREN' => 124,
3759             'LBRACKET' => 125,
3760             'OP10_NAMED_UNARY' => 109,
3761             'WORD_SCOPED' => 25,
3762             'OP22_LOGICAL_NEG_LPAREN' => 106,
3763             'VARIABLE_SYMBOL' => 103,
3764             "undef" => 104,
3765             'CONSTANT_CALL_SCOPED' => 116,
3766             "%{" => 114,
3767             'OP03_MATH_INC_DEC' => 115,
3768             'OP22_LOGICAL_NEG' => 110,
3769             'SELF' => 143
3770             },
3771             GOTOS => {
3772             'WordScoped' => 140,
3773             'ArrayDereference' => 139,
3774             'VariableSymbolOrSelf' => 108,
3775             'HashDereference' => 142,
3776             'SubExpression' => 315,
3777             'HashReference' => 126,
3778             'Literal' => 128,
3779             'Operator' => 111,
3780             'Expression' => 159,
3781             'ArrayReference' => 134,
3782             'Variable' => 164
3783             }
3784             },
3785             {#State 248
3786             ACTIONS => {
3787             "undef" => 104,
3788             'VARIABLE_SYMBOL' => 103,
3789             'OP10_NAMED_UNARY' => 109,
3790             'OP22_LOGICAL_NEG_LPAREN' => 106,
3791             'WORD_SCOPED' => 25,
3792             'OP22_LOGICAL_NEG' => 110,
3793             'SELF' => 143,
3794             "%{" => 114,
3795             'OP03_MATH_INC_DEC' => 115,
3796             'CONSTANT_CALL_SCOPED' => 116,
3797             'OP05_LOGICAL_NEG' => 120,
3798             'OP01_CLOSE' => 93,
3799             'OP01_OPEN' => 92,
3800             'LITERAL_STRING' => 123,
3801             'OP05_BITWISE_NEG_LPAREN' => 122,
3802             'OP01_NAMED' => 165,
3803             'LITERAL_NUMBER' => 98,
3804             'WORD' => 24,
3805             'LPAREN' => 130,
3806             "\@{" => 99,
3807             'WORD_UPPERCASE' => 161,
3808             'LBRACKET' => 125,
3809             'OP05_MATH_NEG_LPAREN' => 124,
3810             'LBRACE' => 100
3811             },
3812             GOTOS => {
3813             'Expression' => 159,
3814             'ArrayReference' => 134,
3815             'Variable' => 164,
3816             'HashReference' => 126,
3817             'Operator' => 111,
3818             'Literal' => 128,
3819             'SubExpression' => 316,
3820             'VariableSymbolOrSelf' => 108,
3821             'HashDereference' => 142,
3822             'ArrayDereference' => 139,
3823             'WordScoped' => 140
3824             }
3825             },
3826             {#State 249
3827             ACTIONS => {
3828             'SELF' => 143,
3829             'OP22_LOGICAL_NEG' => 110,
3830             'OP03_MATH_INC_DEC' => 115,
3831             'CONSTANT_CALL_SCOPED' => 116,
3832             "%{" => 114,
3833             'VARIABLE_SYMBOL' => 103,
3834             "undef" => 104,
3835             'WORD_SCOPED' => 25,
3836             'OP22_LOGICAL_NEG_LPAREN' => 106,
3837             'OP10_NAMED_UNARY' => 109,
3838             'LBRACKET' => 125,
3839             'OP05_MATH_NEG_LPAREN' => 124,
3840             "\@{" => 99,
3841             'LPAREN' => 130,
3842             'WORD_UPPERCASE' => 161,
3843             'LBRACE' => 100,
3844             'OP01_OPEN' => 92,
3845             'OP05_LOGICAL_NEG' => 120,
3846             'OP01_CLOSE' => 93,
3847             'WORD' => 24,
3848             'LITERAL_STRING' => 123,
3849             'OP01_NAMED' => 165,
3850             'OP05_BITWISE_NEG_LPAREN' => 122,
3851             'LITERAL_NUMBER' => 98
3852             },
3853             GOTOS => {
3854             'SubExpression' => 317,
3855             'VariableSymbolOrSelf' => 108,
3856             'HashDereference' => 142,
3857             'ArrayDereference' => 139,
3858             'WordScoped' => 140,
3859             'Variable' => 164,
3860             'ArrayReference' => 134,
3861             'Expression' => 159,
3862             'Operator' => 111,
3863             'Literal' => 128,
3864             'HashReference' => 126
3865             }
3866             },
3867             {#State 250
3868             ACTIONS => {
3869             'WORD' => 24,
3870             'LITERAL_NUMBER' => 98,
3871             'OP01_NAMED' => 165,
3872             'OP05_BITWISE_NEG_LPAREN' => 122,
3873             'LITERAL_STRING' => 123,
3874             'OP01_CLOSE' => 93,
3875             'OP05_LOGICAL_NEG' => 120,
3876             'OP01_OPEN' => 92,
3877             'LBRACE' => 100,
3878             'OP05_MATH_NEG_LPAREN' => 124,
3879             'LBRACKET' => 125,
3880             "\@{" => 99,
3881             'LPAREN' => 130,
3882             'WORD_UPPERCASE' => 161,
3883             'OP22_LOGICAL_NEG_LPAREN' => 106,
3884             'WORD_SCOPED' => 25,
3885             'OP10_NAMED_UNARY' => 109,
3886             "undef" => 104,
3887             'VARIABLE_SYMBOL' => 103,
3888             'OP03_MATH_INC_DEC' => 115,
3889             "%{" => 114,
3890             'CONSTANT_CALL_SCOPED' => 116,
3891             'SELF' => 143,
3892             'OP22_LOGICAL_NEG' => 110
3893             },
3894             GOTOS => {
3895             'Expression' => 159,
3896             'ArrayReference' => 134,
3897             'Variable' => 164,
3898             'HashReference' => 126,
3899             'Literal' => 128,
3900             'Operator' => 111,
3901             'VariableSymbolOrSelf' => 108,
3902             'HashDereference' => 142,
3903             'SubExpression' => 318,
3904             'WordScoped' => 140,
3905             'ArrayDereference' => 139
3906             }
3907             },
3908             {#State 251
3909             ACTIONS => {
3910             'OP06_REGEX_PATTERN' => 319
3911             }
3912             },
3913             {#State 252
3914             ACTIONS => {
3915             'LITERAL_STRING' => 123,
3916             'LITERAL_NUMBER' => 98,
3917             'VARIABLE_SYMBOL' => 103,
3918             'SELF' => 143
3919             },
3920             GOTOS => {
3921             'Literal' => 320,
3922             'VariableOrLiteral' => 321,
3923             'VariableSymbolOrSelf' => 108,
3924             'Variable' => 322
3925             }
3926             },
3927             {#State 253
3928             ACTIONS => {
3929             'CONSTANT_CALL_SCOPED' => 116,
3930             "%{" => 114,
3931             'OP03_MATH_INC_DEC' => 115,
3932             'OP22_LOGICAL_NEG' => 110,
3933             'SELF' => 143,
3934             'OP10_NAMED_UNARY' => 109,
3935             'OP22_LOGICAL_NEG_LPAREN' => 106,
3936             'WORD_SCOPED' => 25,
3937             'VARIABLE_SYMBOL' => 103,
3938             "undef" => 104,
3939             'LBRACE' => 100,
3940             "\@{" => 99,
3941             'WORD_UPPERCASE' => 161,
3942             'LPAREN' => 130,
3943             'LBRACKET' => 125,
3944             'OP05_MATH_NEG_LPAREN' => 124,
3945             'LITERAL_STRING' => 123,
3946             'OP01_NAMED' => 165,
3947             'OP05_BITWISE_NEG_LPAREN' => 122,
3948             'LITERAL_NUMBER' => 98,
3949             'WORD' => 24,
3950             'OP01_CLOSE' => 93,
3951             'OP05_LOGICAL_NEG' => 120,
3952             'OP01_OPEN' => 92
3953             },
3954             GOTOS => {
3955             'Variable' => 164,
3956             'Expression' => 159,
3957             'ArrayReference' => 134,
3958             'Literal' => 128,
3959             'Operator' => 111,
3960             'HashReference' => 126,
3961             'HashDereference' => 142,
3962             'VariableSymbolOrSelf' => 108,
3963             'SubExpression' => 323,
3964             'ArrayDereference' => 139,
3965             'WordScoped' => 140
3966             }
3967             },
3968             {#State 254
3969             DEFAULT => -163
3970             },
3971             {#State 255
3972             DEFAULT => -99
3973             },
3974             {#State 256
3975             ACTIONS => {
3976             'WORD' => 24,
3977             'LITERAL_NUMBER' => 98,
3978             'OP01_NAMED' => 165,
3979             'OP05_BITWISE_NEG_LPAREN' => 122,
3980             'LITERAL_STRING' => 123,
3981             'OP01_CLOSE' => 93,
3982             'OP01_OPEN' => 92,
3983             'OP05_LOGICAL_NEG' => 120,
3984             'LBRACE' => 100,
3985             'OP05_MATH_NEG_LPAREN' => 124,
3986             'LBRACKET' => 125,
3987             "\@{" => 99,
3988             'WORD_UPPERCASE' => 161,
3989             'LPAREN' => 130,
3990             'WORD_SCOPED' => 25,
3991             'OP22_LOGICAL_NEG_LPAREN' => 106,
3992             'OP10_NAMED_UNARY' => 109,
3993             'STDIN' => 326,
3994             "undef" => 104,
3995             'VARIABLE_SYMBOL' => 103,
3996             'OP03_MATH_INC_DEC' => 115,
3997             'CONSTANT_CALL_SCOPED' => 116,
3998             "%{" => 114,
3999             'FHREF_SYMBOL_IN' => 325,
4000             'SELF' => 143,
4001             'OP22_LOGICAL_NEG' => 110
4002             },
4003             GOTOS => {
4004             'Variable' => 164,
4005             'Expression' => 159,
4006             'ArrayReference' => 134,
4007             'SubExpressionOrInput' => 327,
4008             'Literal' => 128,
4009             'Operator' => 111,
4010             'HashReference' => 126,
4011             'HashDereference' => 142,
4012             'VariableSymbolOrSelf' => 108,
4013             'SubExpression' => 324,
4014             'ArrayDereference' => 139,
4015             'WordScoped' => 140
4016             }
4017             },
4018             {#State 257
4019             ACTIONS => {
4020             'LPAREN' => 130,
4021             "\@{" => 99,
4022             'WORD_UPPERCASE' => 161,
4023             'LBRACKET' => 125,
4024             'OP05_MATH_NEG_LPAREN' => 124,
4025             'LBRACE' => 100,
4026             'OP01_CLOSE' => 93,
4027             'OP05_LOGICAL_NEG' => 120,
4028             'OP01_OPEN' => 92,
4029             'LITERAL_NUMBER' => 98,
4030             'LITERAL_STRING' => 123,
4031             'OP01_NAMED' => 165,
4032             'OP05_BITWISE_NEG_LPAREN' => 122,
4033             'WORD' => 24,
4034             'OP22_LOGICAL_NEG' => 110,
4035             'SELF' => 143,
4036             "%{" => 114,
4037             'CONSTANT_CALL_SCOPED' => 116,
4038             'OP03_MATH_INC_DEC' => 115,
4039             "undef" => 104,
4040             'VARIABLE_SYMBOL' => 103,
4041             'OP10_NAMED_UNARY' => 109,
4042             'OP22_LOGICAL_NEG_LPAREN' => 106,
4043             'WORD_SCOPED' => 25
4044             },
4045             GOTOS => {
4046             'Operator' => 111,
4047             'Literal' => 128,
4048             'HashReference' => 126,
4049             'Variable' => 164,
4050             'Expression' => 159,
4051             'ArrayReference' => 134,
4052             'WordScoped' => 140,
4053             'ArrayDereference' => 139,
4054             'SubExpression' => 328,
4055             'VariableSymbolOrSelf' => 108,
4056             'HashDereference' => 142
4057             }
4058             },
4059             {#State 258
4060             ACTIONS => {
4061             'LPAREN' => 329
4062             }
4063             },
4064             {#State 259
4065             ACTIONS => {
4066             'OP19_VARIABLE_ASSIGN' => 330
4067             }
4068             },
4069             {#State 260
4070             DEFAULT => -71,
4071             GOTOS => {
4072             'STAR-30' => 331
4073             }
4074             },
4075             {#State 261
4076             DEFAULT => -68
4077             },
4078             {#State 262
4079             DEFAULT => -52
4080             },
4081             {#State 263
4082             ACTIONS => {
4083             'WORD_UPPERCASE' => 332
4084             }
4085             },
4086             {#State 264
4087             ACTIONS => {
4088             "\$RETURN_TYPE" => 333
4089             }
4090             },
4091             {#State 265
4092             ACTIONS => {
4093             'FHREF_SYMBOL' => 334
4094             }
4095             },
4096             {#State 266
4097             DEFAULT => -136
4098             },
4099             {#State 267
4100             ACTIONS => {
4101             'ARGV' => 166,
4102             'OP03_MATH_INC_DEC' => 115,
4103             'CONSTANT_CALL_SCOPED' => 116,
4104             "%{" => 114,
4105             'OP22_LOGICAL_NEG' => 110,
4106             'OP01_QW' => 167,
4107             'SELF' => 143,
4108             'OP10_NAMED_UNARY' => 109,
4109             'WORD_SCOPED' => 25,
4110             'OP22_LOGICAL_NEG_LPAREN' => 106,
4111             "undef" => 104,
4112             'VARIABLE_SYMBOL' => 103,
4113             'LBRACE' => 100,
4114             'MY' => 160,
4115             "\@{" => 99,
4116             'WORD_UPPERCASE' => 161,
4117             'LPAREN' => 130,
4118             'LBRACKET' => 125,
4119             'OP05_MATH_NEG_LPAREN' => 124,
4120             'LITERAL_NUMBER' => 98,
4121             'OP01_NAMED' => 165,
4122             'LITERAL_STRING' => 123,
4123             'OP05_BITWISE_NEG_LPAREN' => 122,
4124             'WORD' => 24,
4125             'OP01_CLOSE' => 93,
4126             'OP05_LOGICAL_NEG' => 120,
4127             'OP01_OPEN' => 92
4128             },
4129             GOTOS => {
4130             'HashDereference' => 142,
4131             'VariableSymbolOrSelf' => 108,
4132             'ListElement' => 209,
4133             'SubExpression' => 210,
4134             'WordScoped' => 140,
4135             'ArrayDereference' => 139,
4136             'TypeInner' => 163,
4137             'Variable' => 164,
4138             'Expression' => 159,
4139             'ArrayReference' => 134,
4140             'Operator' => 111,
4141             'ListElements' => 335,
4142             'Literal' => 128,
4143             'HashReference' => 126
4144             }
4145             },
4146             {#State 268
4147             ACTIONS => {
4148             "\$TYPED_" => 336
4149             }
4150             },
4151             {#State 269
4152             ACTIONS => {
4153             'OP23_LOGICAL_AND' => 246,
4154             'OP04_MATH_POW' => 247,
4155             'OP08_MATH_ADD_SUB' => 244,
4156             'OP08_STRING_CAT' => 245,
4157             "]" => -206,
4158             ")" => -206,
4159             'OP16_LOGICAL_OR' => 253,
4160             'OP06_REGEX_BIND' => 251,
4161             'OP13_BITWISE_AND' => 243,
4162             'OP18_TERNARY' => 252,
4163             'OP24_LOGICAL_OR_XOR' => 242,
4164             'OP17_LIST_RANGE' => 241,
4165             'OP12_COMPARE_EQ_NE' => 239,
4166             'OP21_LIST_COMMA' => -206,
4167             ";" => -206,
4168             'OP11_COMPARE_LT_GT' => 249,
4169             'OP07_MATH_MULT_DIV_MOD' => 240,
4170             'OP09_BITWISE_SHIFT' => 250,
4171             'OP14_BITWISE_OR_XOR' => 237,
4172             'OP15_LOGICAL_AND' => 248,
4173             'OP07_STRING_REPEAT' => 238
4174             }
4175             },
4176             {#State 270
4177             ACTIONS => {
4178             'OP23_LOGICAL_AND' => -94,
4179             'OP04_MATH_POW' => -94,
4180             'OP08_MATH_ADD_SUB' => -94,
4181             'OP08_STRING_CAT' => -94,
4182             "]" => -94,
4183             ")" => -94,
4184             'OP16_LOGICAL_OR' => -94,
4185             'OP13_BITWISE_AND' => -94,
4186             'OP06_REGEX_BIND' => -94,
4187             'OP18_TERNARY' => -94,
4188             'OP24_LOGICAL_OR_XOR' => -94,
4189             'OP17_LIST_RANGE' => -94,
4190             "}" => -94,
4191             'OP12_COMPARE_EQ_NE' => -94,
4192             'OP21_LIST_COMMA' => -94,
4193             ";" => -94,
4194             'OP09_BITWISE_SHIFT' => -94,
4195             'OP07_MATH_MULT_DIV_MOD' => -94,
4196             'OP11_COMPARE_LT_GT' => -94,
4197             'OP15_LOGICAL_AND' => -94,
4198             'OP07_STRING_REPEAT' => -94,
4199             'OP14_BITWISE_OR_XOR' => -94
4200             }
4201             },
4202             {#State 271
4203             DEFAULT => -214
4204             },
4205             {#State 272
4206             ACTIONS => {
4207             "}" => 337
4208             }
4209             },
4210             {#State 273
4211             ACTIONS => {
4212             'WORD' => -217,
4213             'LITERAL_NUMBER' => -217,
4214             'OP01_NAMED' => -217,
4215             'OP05_BITWISE_NEG_LPAREN' => -217,
4216             'LITERAL_STRING' => -217,
4217             'OP01_CLOSE' => -217,
4218             'OP01_OPEN' => -217,
4219             'OP05_LOGICAL_NEG' => -217,
4220             'LBRACE' => -217,
4221             'OP05_MATH_NEG_LPAREN' => -217,
4222             'LBRACKET' => -217,
4223             'MY' => 160,
4224             'WORD_UPPERCASE' => -217,
4225             'LPAREN' => -217,
4226             "\@{" => -217,
4227             'OP22_LOGICAL_NEG_LPAREN' => -217,
4228             'WORD_SCOPED' => -217,
4229             'OP10_NAMED_UNARY' => -217,
4230             "undef" => -217,
4231             'VARIABLE_SYMBOL' => -217,
4232             'CONSTANT_CALL_SCOPED' => -217,
4233             "%{" => -217,
4234             'OP03_MATH_INC_DEC' => -217,
4235             'SELF' => -217,
4236             'OP22_LOGICAL_NEG' => -217
4237             },
4238             GOTOS => {
4239             'OPTIONAL-55' => 339,
4240             'TypeInner' => 338
4241             }
4242             },
4243             {#State 274
4244             ACTIONS => {
4245             'OP21_LIST_COMMA' => 341,
4246             "}" => 342
4247             },
4248             GOTOS => {
4249             'PAREN-56' => 340
4250             }
4251             },
4252             {#State 275
4253             ACTIONS => {
4254             'LBRACE' => 100,
4255             "\@{" => 99,
4256             'LPAREN' => 130,
4257             'WORD_UPPERCASE' => 161,
4258             'OP05_MATH_NEG_LPAREN' => 124,
4259             'LBRACKET' => 125,
4260             'LITERAL_NUMBER' => 98,
4261             'LITERAL_STRING' => 123,
4262             'OP05_BITWISE_NEG_LPAREN' => 122,
4263             'OP01_NAMED' => 165,
4264             'WORD' => 24,
4265             'OP01_CLOSE' => 93,
4266             'OP05_LOGICAL_NEG' => 120,
4267             'OP01_OPEN' => 92,
4268             "%{" => 114,
4269             'CONSTANT_CALL_SCOPED' => 116,
4270             'OP03_MATH_INC_DEC' => 115,
4271             'OP22_LOGICAL_NEG' => 110,
4272             'SELF' => 143,
4273             'OP10_NAMED_UNARY' => 109,
4274             'OP22_LOGICAL_NEG_LPAREN' => 106,
4275             'WORD_SCOPED' => 25,
4276             "undef" => 104,
4277             'VARIABLE_SYMBOL' => 103
4278             },
4279             GOTOS => {
4280             'Operator' => 111,
4281             'Literal' => 128,
4282             'HashReference' => 126,
4283             'Variable' => 164,
4284             'ArrayReference' => 134,
4285             'Expression' => 159,
4286             'WordScoped' => 140,
4287             'ArrayDereference' => 139,
4288             'SubExpression' => 343,
4289             'VariableSymbolOrSelf' => 108,
4290             'HashDereference' => 142
4291             }
4292             },
4293             {#State 276
4294             ACTIONS => {
4295             'WORD' => 152,
4296             'WORD_SCOPED' => 150,
4297             'TYPE_INTEGER' => 149
4298             },
4299             GOTOS => {
4300             'Type' => 344
4301             }
4302             },
4303             {#State 277
4304             ACTIONS => {
4305             'TYPE_INTEGER' => 345
4306             }
4307             },
4308             {#State 278
4309             ACTIONS => {
4310             'TYPE_INTEGER' => 346
4311             }
4312             },
4313             {#State 279
4314             ACTIONS => {
4315             'WORD_SCOPED' => 150,
4316             'WORD' => 152,
4317             'TYPE_INTEGER' => 149
4318             },
4319             GOTOS => {
4320             'Type' => 347
4321             }
4322             },
4323             {#State 280
4324             ACTIONS => {
4325             ";" => 348
4326             }
4327             },
4328             {#State 281
4329             ACTIONS => {
4330             ";" => 349
4331             }
4332             },
4333             {#State 282
4334             DEFAULT => -120
4335             },
4336             {#State 283
4337             DEFAULT => -133
4338             },
4339             {#State 284
4340             ACTIONS => {
4341             'OP21_LIST_COMMA' => 350,
4342             ")" => -204,
4343             ";" => -204,
4344             "]" => -204
4345             },
4346             GOTOS => {
4347             'PAREN-51' => 351
4348             }
4349             },
4350             {#State 285
4351             ACTIONS => {
4352             'OP22_LOGICAL_NEG' => 110,
4353             'SELF' => 143,
4354             'OP03_MATH_INC_DEC' => 115,
4355             'CONSTANT_CALL_SCOPED' => 116,
4356             "%{" => 114,
4357             "undef" => 104,
4358             'VARIABLE_SYMBOL' => 103,
4359             'OP10_NAMED_UNARY' => 109,
4360             'OP22_LOGICAL_NEG_LPAREN' => 106,
4361             'WORD_SCOPED' => 25,
4362             "\@{" => 99,
4363             'LPAREN' => 130,
4364             'WORD_UPPERCASE' => 161,
4365             'LBRACKET' => 125,
4366             'OP05_MATH_NEG_LPAREN' => 124,
4367             'LBRACE' => 100,
4368             'OP01_OPEN' => 92,
4369             'OP01_CLOSE' => 93,
4370             'OP05_LOGICAL_NEG' => 120,
4371             'LITERAL_NUMBER' => 98,
4372             'OP01_NAMED' => 165,
4373             'OP05_BITWISE_NEG_LPAREN' => 122,
4374             'LITERAL_STRING' => 123,
4375             'WORD' => 353
4376             },
4377             GOTOS => {
4378             'VariableSymbolOrSelf' => 108,
4379             'HashDereference' => 142,
4380             'SubExpression' => 352,
4381             'ArrayDereference' => 139,
4382             'WordScoped' => 140,
4383             'ArrayReference' => 134,
4384             'Expression' => 159,
4385             'Variable' => 164,
4386             'HashReference' => 126,
4387             'Literal' => 128,
4388             'Operator' => 111
4389             }
4390             },
4391             {#State 286
4392             ACTIONS => {
4393             'OP01_OPEN' => 92,
4394             'OP01_CLOSE' => 93,
4395             'OP05_LOGICAL_NEG' => 120,
4396             'WORD' => 24,
4397             'LITERAL_NUMBER' => 98,
4398             'OP01_NAMED' => 165,
4399             'OP05_BITWISE_NEG_LPAREN' => 122,
4400             'LITERAL_STRING' => 123,
4401             'LBRACKET' => 125,
4402             'OP05_MATH_NEG_LPAREN' => 124,
4403             'WORD_UPPERCASE' => 161,
4404             "\@{" => 99,
4405             'LPAREN' => 130,
4406             'LBRACE' => 100,
4407             "undef" => 104,
4408             'VARIABLE_SYMBOL' => 103,
4409             'WORD_SCOPED' => 25,
4410             'OP22_LOGICAL_NEG_LPAREN' => 106,
4411             'OP10_NAMED_UNARY' => 109,
4412             'SELF' => 143,
4413             'OP22_LOGICAL_NEG' => 110,
4414             "%{" => 114,
4415             'OP03_MATH_INC_DEC' => 115,
4416             'CONSTANT_CALL_SCOPED' => 116
4417             },
4418             GOTOS => {
4419             'WordScoped' => 140,
4420             'ArrayDereference' => 139,
4421             'HashDereference' => 142,
4422             'VariableSymbolOrSelf' => 108,
4423             'SubExpression' => 354,
4424             'HashReference' => 126,
4425             'Literal' => 128,
4426             'Operator' => 111,
4427             'ArrayReference' => 134,
4428             'Expression' => 159,
4429             'Variable' => 164
4430             }
4431             },
4432             {#State 287
4433             DEFAULT => -189
4434             },
4435             {#State 288
4436             ACTIONS => {
4437             ";" => 355
4438             }
4439             },
4440             {#State 289
4441             DEFAULT => -229
4442             },
4443             {#State 290
4444             ACTIONS => {
4445             "}" => 356
4446             }
4447             },
4448             {#State 291
4449             DEFAULT => -101
4450             },
4451             {#State 292
4452             DEFAULT => -103
4453             },
4454             {#State 293
4455             DEFAULT => -211
4456             },
4457             {#State 294
4458             DEFAULT => -144
4459             },
4460             {#State 295
4461             ACTIONS => {
4462             'OP22_LOGICAL_NEG' => 110,
4463             'SELF' => 143,
4464             'OP01_QW' => 167,
4465             'ARGV' => 166,
4466             'OP03_MATH_INC_DEC' => 115,
4467             'CONSTANT_CALL_SCOPED' => 116,
4468             "%{" => 114,
4469             "undef" => 104,
4470             'VARIABLE_SYMBOL' => 103,
4471             'OP10_NAMED_UNARY' => 109,
4472             'OP22_LOGICAL_NEG_LPAREN' => 106,
4473             'WORD_SCOPED' => 25,
4474             "\@{" => 99,
4475             'LPAREN' => 130,
4476             'WORD_UPPERCASE' => 161,
4477             'MY' => 160,
4478             'LBRACKET' => 125,
4479             'OP05_MATH_NEG_LPAREN' => 124,
4480             'LBRACE' => 100,
4481             'OP01_CLOSE' => 93,
4482             'OP01_OPEN' => 92,
4483             'OP05_LOGICAL_NEG' => 120,
4484             'OP01_NAMED' => 165,
4485             'LITERAL_STRING' => 123,
4486             'OP05_BITWISE_NEG_LPAREN' => 122,
4487             'LITERAL_NUMBER' => 98,
4488             'WORD' => 24
4489             },
4490             GOTOS => {
4491             'WordScoped' => 140,
4492             'ArrayDereference' => 139,
4493             'TypeInner' => 163,
4494             'SubExpression' => 210,
4495             'VariableSymbolOrSelf' => 108,
4496             'HashDereference' => 142,
4497             'ListElement' => 209,
4498             'HashReference' => 126,
4499             'ListElements' => 357,
4500             'Literal' => 128,
4501             'Operator' => 111,
4502             'ArrayReference' => 134,
4503             'Expression' => 159,
4504             'Variable' => 164
4505             }
4506             },
4507             {#State 296
4508             ACTIONS => {
4509             'OP21_LIST_COMMA' => 358
4510             }
4511             },
4512             {#State 297
4513             DEFAULT => -157
4514             },
4515             {#State 298
4516             ACTIONS => {
4517             'OP02_ARRAY_THINARROW' => 360,
4518             'OP19_VARIABLE_ASSIGN' => 359,
4519             ";" => 361
4520             }
4521             },
4522             {#State 299
4523             ACTIONS => {
4524             ";" => 362
4525             }
4526             },
4527             {#State 300
4528             ACTIONS => {
4529             'OP07_STRING_REPEAT' => 238,
4530             'OP15_LOGICAL_AND' => 248,
4531             'OP14_BITWISE_OR_XOR' => 237,
4532             'OP11_COMPARE_LT_GT' => 249,
4533             'OP07_MATH_MULT_DIV_MOD' => 240,
4534             'OP09_BITWISE_SHIFT' => 250,
4535             'OP12_COMPARE_EQ_NE' => 239,
4536             'OP17_LIST_RANGE' => 241,
4537             'OP24_LOGICAL_OR_XOR' => 242,
4538             'OP18_TERNARY' => 252,
4539             'OP06_REGEX_BIND' => 251,
4540             'OP13_BITWISE_AND' => 243,
4541             'OP16_LOGICAL_OR' => 253,
4542             ")" => 363,
4543             'OP08_STRING_CAT' => 245,
4544             'OP08_MATH_ADD_SUB' => 244,
4545             'OP04_MATH_POW' => 247,
4546             'OP23_LOGICAL_AND' => 246
4547             }
4548             },
4549             {#State 301
4550             DEFAULT => -137
4551             },
4552             {#State 302
4553             ACTIONS => {
4554             ")" => 364
4555             }
4556             },
4557             {#State 303
4558             ACTIONS => {
4559             ")" => 365
4560             }
4561             },
4562             {#State 304
4563             DEFAULT => -141
4564             },
4565             {#State 305
4566             ACTIONS => {
4567             'OP23_LOGICAL_AND' => -115,
4568             'OP04_MATH_POW' => 247,
4569             "]" => -115,
4570             'OP08_STRING_CAT' => 245,
4571             'OP08_MATH_ADD_SUB' => 244,
4572             ")" => -115,
4573             'OP16_LOGICAL_OR' => -115,
4574             'OP06_REGEX_BIND' => 251,
4575             'OP13_BITWISE_AND' => 243,
4576             'OP18_TERNARY' => -115,
4577             'OP24_LOGICAL_OR_XOR' => -115,
4578             'OP17_LIST_RANGE' => -115,
4579             "}" => -115,
4580             'OP21_LIST_COMMA' => -115,
4581             'OP12_COMPARE_EQ_NE' => 239,
4582             'OP09_BITWISE_SHIFT' => 250,
4583             'OP11_COMPARE_LT_GT' => 249,
4584             'OP07_MATH_MULT_DIV_MOD' => 240,
4585             ";" => -115,
4586             'OP14_BITWISE_OR_XOR' => -115,
4587             'OP15_LOGICAL_AND' => -115,
4588             'OP07_STRING_REPEAT' => 238
4589             }
4590             },
4591             {#State 306
4592             ACTIONS => {
4593             'OP12_COMPARE_EQ_NE' => -105,
4594             'OP21_LIST_COMMA' => -105,
4595             ";" => -105,
4596             'OP11_COMPARE_LT_GT' => -105,
4597             'OP07_MATH_MULT_DIV_MOD' => -105,
4598             'OP09_BITWISE_SHIFT' => -105,
4599             'OP14_BITWISE_OR_XOR' => -105,
4600             'OP15_LOGICAL_AND' => -105,
4601             'OP07_STRING_REPEAT' => -105,
4602             'OP24_LOGICAL_OR_XOR' => -105,
4603             'OP17_LIST_RANGE' => -105,
4604             "}" => -105,
4605             ")" => -105,
4606             'OP16_LOGICAL_OR' => -105,
4607             'OP13_BITWISE_AND' => -105,
4608             'OP06_REGEX_BIND' => 251,
4609             'OP18_TERNARY' => -105,
4610             'OP23_LOGICAL_AND' => -105,
4611             'OP04_MATH_POW' => 247,
4612             'OP08_MATH_ADD_SUB' => -105,
4613             "]" => -105,
4614             'OP08_STRING_CAT' => -105
4615             }
4616             },
4617             {#State 307
4618             ACTIONS => {
4619             'OP18_TERNARY' => -113,
4620             'OP06_REGEX_BIND' => 251,
4621             'OP13_BITWISE_AND' => -113,
4622             'OP16_LOGICAL_OR' => -113,
4623             ")" => -113,
4624             'OP08_STRING_CAT' => 245,
4625             "]" => -113,
4626             'OP08_MATH_ADD_SUB' => 244,
4627             'OP04_MATH_POW' => 247,
4628             'OP23_LOGICAL_AND' => -113,
4629             'OP14_BITWISE_OR_XOR' => -113,
4630             'OP07_STRING_REPEAT' => 238,
4631             'OP15_LOGICAL_AND' => -113,
4632             'OP09_BITWISE_SHIFT' => 250,
4633             'OP07_MATH_MULT_DIV_MOD' => 240,
4634             'OP11_COMPARE_LT_GT' => 249,
4635             ";" => -113,
4636             'OP21_LIST_COMMA' => -113,
4637             'OP12_COMPARE_EQ_NE' => undef,
4638             "}" => -113,
4639             'OP17_LIST_RANGE' => -113,
4640             'OP24_LOGICAL_OR_XOR' => -113
4641             }
4642             },
4643             {#State 308
4644             ACTIONS => {
4645             ")" => -106,
4646             'OP16_LOGICAL_OR' => -106,
4647             'OP06_REGEX_BIND' => 251,
4648             'OP13_BITWISE_AND' => -106,
4649             'OP18_TERNARY' => -106,
4650             'OP23_LOGICAL_AND' => -106,
4651             'OP04_MATH_POW' => 247,
4652             'OP08_STRING_CAT' => -106,
4653             "]" => -106,
4654             'OP08_MATH_ADD_SUB' => -106,
4655             'OP21_LIST_COMMA' => -106,
4656             'OP12_COMPARE_EQ_NE' => -106,
4657             'OP07_MATH_MULT_DIV_MOD' => -106,
4658             'OP09_BITWISE_SHIFT' => -106,
4659             'OP11_COMPARE_LT_GT' => -106,
4660             ";" => -106,
4661             'OP07_STRING_REPEAT' => 238,
4662             'OP14_BITWISE_OR_XOR' => -106,
4663             'OP15_LOGICAL_AND' => -106,
4664             'OP24_LOGICAL_OR_XOR' => -106,
4665             'OP17_LIST_RANGE' => -106,
4666             "}" => -106
4667             }
4668             },
4669             {#State 309
4670             ACTIONS => {
4671             ")" => -118,
4672             'OP16_LOGICAL_OR' => 253,
4673             'OP06_REGEX_BIND' => 251,
4674             'OP13_BITWISE_AND' => 243,
4675             'OP18_TERNARY' => -118,
4676             'OP23_LOGICAL_AND' => -118,
4677             'OP04_MATH_POW' => 247,
4678             'OP08_STRING_CAT' => 245,
4679             "]" => -118,
4680             'OP08_MATH_ADD_SUB' => 244,
4681             'OP21_LIST_COMMA' => -118,
4682             'OP12_COMPARE_EQ_NE' => 239,
4683             'OP07_MATH_MULT_DIV_MOD' => 240,
4684             'OP09_BITWISE_SHIFT' => 250,
4685             'OP11_COMPARE_LT_GT' => 249,
4686             ";" => -118,
4687             'OP15_LOGICAL_AND' => 248,
4688             'OP07_STRING_REPEAT' => 238,
4689             'OP14_BITWISE_OR_XOR' => 237,
4690             'OP24_LOGICAL_OR_XOR' => -118,
4691             'OP17_LIST_RANGE' => undef,
4692             "}" => -118
4693             }
4694             },
4695             {#State 310
4696             ACTIONS => {
4697             'OP12_COMPARE_EQ_NE' => 239,
4698             'OP21_LIST_COMMA' => -123,
4699             ";" => -123,
4700             'OP09_BITWISE_SHIFT' => 250,
4701             'OP07_MATH_MULT_DIV_MOD' => 240,
4702             'OP11_COMPARE_LT_GT' => 249,
4703             'OP14_BITWISE_OR_XOR' => 237,
4704             'OP15_LOGICAL_AND' => 248,
4705             'OP07_STRING_REPEAT' => 238,
4706             'OP24_LOGICAL_OR_XOR' => -123,
4707             'OP17_LIST_RANGE' => 241,
4708             "}" => -123,
4709             ")" => -123,
4710             'OP16_LOGICAL_OR' => 253,
4711             'OP06_REGEX_BIND' => 251,
4712             'OP13_BITWISE_AND' => 243,
4713             'OP18_TERNARY' => 252,
4714             'OP23_LOGICAL_AND' => 246,
4715             'OP04_MATH_POW' => 247,
4716             'OP08_MATH_ADD_SUB' => 244,
4717             'OP08_STRING_CAT' => 245,
4718             "]" => -123
4719             }
4720             },
4721             {#State 311
4722             ACTIONS => {
4723             'OP24_LOGICAL_OR_XOR' => -114,
4724             'OP17_LIST_RANGE' => -114,
4725             "}" => -114,
4726             'OP12_COMPARE_EQ_NE' => 239,
4727             'OP21_LIST_COMMA' => -114,
4728             ";" => -114,
4729             'OP11_COMPARE_LT_GT' => 249,
4730             'OP07_MATH_MULT_DIV_MOD' => 240,
4731             'OP09_BITWISE_SHIFT' => 250,
4732             'OP15_LOGICAL_AND' => -114,
4733             'OP07_STRING_REPEAT' => 238,
4734             'OP14_BITWISE_OR_XOR' => -114,
4735             'OP23_LOGICAL_AND' => -114,
4736             'OP04_MATH_POW' => 247,
4737             'OP08_MATH_ADD_SUB' => 244,
4738             "]" => -114,
4739             'OP08_STRING_CAT' => 245,
4740             ")" => -114,
4741             'OP16_LOGICAL_OR' => -114,
4742             'OP13_BITWISE_AND' => -114,
4743             'OP06_REGEX_BIND' => 251,
4744             'OP18_TERNARY' => -114
4745             }
4746             },
4747             {#State 312
4748             ACTIONS => {
4749             'OP17_LIST_RANGE' => -107,
4750             "}" => -107,
4751             'OP24_LOGICAL_OR_XOR' => -107,
4752             'OP15_LOGICAL_AND' => -107,
4753             'OP07_STRING_REPEAT' => 238,
4754             'OP14_BITWISE_OR_XOR' => -107,
4755             'OP21_LIST_COMMA' => -107,
4756             'OP12_COMPARE_EQ_NE' => -107,
4757             'OP07_MATH_MULT_DIV_MOD' => 240,
4758             'OP11_COMPARE_LT_GT' => -107,
4759             'OP09_BITWISE_SHIFT' => -107,
4760             ";" => -107,
4761             "]" => -107,
4762             'OP08_STRING_CAT' => -107,
4763             'OP08_MATH_ADD_SUB' => -107,
4764             'OP23_LOGICAL_AND' => -107,
4765             'OP04_MATH_POW' => 247,
4766             'OP13_BITWISE_AND' => -107,
4767             'OP06_REGEX_BIND' => 251,
4768             'OP18_TERNARY' => -107,
4769             ")" => -107,
4770             'OP16_LOGICAL_OR' => -107
4771             }
4772             },
4773             {#State 313
4774             ACTIONS => {
4775             'OP13_BITWISE_AND' => -108,
4776             'OP06_REGEX_BIND' => 251,
4777             'OP18_TERNARY' => -108,
4778             ")" => -108,
4779             'OP16_LOGICAL_OR' => -108,
4780             'OP08_MATH_ADD_SUB' => 244,
4781             "]" => -108,
4782             'OP08_STRING_CAT' => -108,
4783             'OP23_LOGICAL_AND' => -108,
4784             'OP04_MATH_POW' => 247,
4785             'OP07_STRING_REPEAT' => 238,
4786             'OP14_BITWISE_OR_XOR' => -108,
4787             'OP15_LOGICAL_AND' => -108,
4788             'OP12_COMPARE_EQ_NE' => -108,
4789             'OP21_LIST_COMMA' => -108,
4790             ";" => -108,
4791             'OP09_BITWISE_SHIFT' => -108,
4792             'OP07_MATH_MULT_DIV_MOD' => 240,
4793             'OP11_COMPARE_LT_GT' => -108,
4794             'OP17_LIST_RANGE' => -108,
4795             "}" => -108,
4796             'OP24_LOGICAL_OR_XOR' => -108
4797             }
4798             },
4799             {#State 314
4800             ACTIONS => {
4801             'OP24_LOGICAL_OR_XOR' => -122,
4802             "}" => -122,
4803             'OP17_LIST_RANGE' => 241,
4804             'OP07_MATH_MULT_DIV_MOD' => 240,
4805             'OP09_BITWISE_SHIFT' => 250,
4806             'OP11_COMPARE_LT_GT' => 249,
4807             ";" => -122,
4808             'OP21_LIST_COMMA' => -122,
4809             'OP12_COMPARE_EQ_NE' => 239,
4810             'OP15_LOGICAL_AND' => 248,
4811             'OP07_STRING_REPEAT' => 238,
4812             'OP14_BITWISE_OR_XOR' => 237,
4813             'OP04_MATH_POW' => 247,
4814             'OP23_LOGICAL_AND' => -122,
4815             "]" => -122,
4816             'OP08_STRING_CAT' => 245,
4817             'OP08_MATH_ADD_SUB' => 244,
4818             'OP16_LOGICAL_OR' => 253,
4819             ")" => -122,
4820             'OP18_TERNARY' => 252,
4821             'OP13_BITWISE_AND' => 243,
4822             'OP06_REGEX_BIND' => 251
4823             }
4824             },
4825             {#State 315
4826             ACTIONS => {
4827             'OP24_LOGICAL_OR_XOR' => -100,
4828             'OP17_LIST_RANGE' => -100,
4829             "}" => -100,
4830             'OP12_COMPARE_EQ_NE' => -100,
4831             'OP21_LIST_COMMA' => -100,
4832             ";" => -100,
4833             'OP09_BITWISE_SHIFT' => -100,
4834             'OP07_MATH_MULT_DIV_MOD' => -100,
4835             'OP11_COMPARE_LT_GT' => -100,
4836             'OP07_STRING_REPEAT' => -100,
4837             'OP15_LOGICAL_AND' => -100,
4838             'OP14_BITWISE_OR_XOR' => -100,
4839             'OP23_LOGICAL_AND' => -100,
4840             'OP04_MATH_POW' => 247,
4841             'OP08_MATH_ADD_SUB' => -100,
4842             "]" => -100,
4843             'OP08_STRING_CAT' => -100,
4844             ")" => -100,
4845             'OP16_LOGICAL_OR' => -100,
4846             'OP06_REGEX_BIND' => -100,
4847             'OP13_BITWISE_AND' => -100,
4848             'OP18_TERNARY' => -100
4849             }
4850             },
4851             {#State 316
4852             ACTIONS => {
4853             'OP08_STRING_CAT' => 245,
4854             "]" => -116,
4855             'OP08_MATH_ADD_SUB' => 244,
4856             'OP04_MATH_POW' => 247,
4857             'OP23_LOGICAL_AND' => -116,
4858             'OP18_TERNARY' => -116,
4859             'OP06_REGEX_BIND' => 251,
4860             'OP13_BITWISE_AND' => 243,
4861             'OP16_LOGICAL_OR' => -116,
4862             ")" => -116,
4863             "}" => -116,
4864             'OP17_LIST_RANGE' => -116,
4865             'OP24_LOGICAL_OR_XOR' => -116,
4866             'OP14_BITWISE_OR_XOR' => 237,
4867             'OP07_STRING_REPEAT' => 238,
4868             'OP15_LOGICAL_AND' => -116,
4869             'OP07_MATH_MULT_DIV_MOD' => 240,
4870             'OP09_BITWISE_SHIFT' => 250,
4871             'OP11_COMPARE_LT_GT' => 249,
4872             ";" => -116,
4873             'OP21_LIST_COMMA' => -116,
4874             'OP12_COMPARE_EQ_NE' => 239
4875             }
4876             },
4877             {#State 317
4878             ACTIONS => {
4879             'OP04_MATH_POW' => 247,
4880             'OP23_LOGICAL_AND' => -112,
4881             "]" => -112,
4882             'OP08_STRING_CAT' => 245,
4883             'OP08_MATH_ADD_SUB' => 244,
4884             'OP16_LOGICAL_OR' => -112,
4885             ")" => -112,
4886             'OP18_TERNARY' => -112,
4887             'OP06_REGEX_BIND' => 251,
4888             'OP13_BITWISE_AND' => -112,
4889             'OP24_LOGICAL_OR_XOR' => -112,
4890             "}" => -112,
4891             'OP17_LIST_RANGE' => -112,
4892             'OP09_BITWISE_SHIFT' => 250,
4893             'OP11_COMPARE_LT_GT' => undef,
4894             'OP07_MATH_MULT_DIV_MOD' => 240,
4895             ";" => -112,
4896             'OP21_LIST_COMMA' => -112,
4897             'OP12_COMPARE_EQ_NE' => -112,
4898             'OP15_LOGICAL_AND' => -112,
4899             'OP14_BITWISE_OR_XOR' => -112,
4900             'OP07_STRING_REPEAT' => 238
4901             }
4902             },
4903             {#State 318
4904             ACTIONS => {
4905             'OP24_LOGICAL_OR_XOR' => -109,
4906             "}" => -109,
4907             'OP17_LIST_RANGE' => -109,
4908             'OP11_COMPARE_LT_GT' => -109,
4909             'OP09_BITWISE_SHIFT' => -109,
4910             'OP07_MATH_MULT_DIV_MOD' => 240,
4911             ";" => -109,
4912             'OP21_LIST_COMMA' => -109,
4913             'OP12_COMPARE_EQ_NE' => -109,
4914             'OP15_LOGICAL_AND' => -109,
4915             'OP07_STRING_REPEAT' => 238,
4916             'OP14_BITWISE_OR_XOR' => -109,
4917             'OP04_MATH_POW' => 247,
4918             'OP23_LOGICAL_AND' => -109,
4919             'OP08_STRING_CAT' => 245,
4920             "]" => -109,
4921             'OP08_MATH_ADD_SUB' => 244,
4922             'OP16_LOGICAL_OR' => -109,
4923             ")" => -109,
4924             'OP18_TERNARY' => -109,
4925             'OP13_BITWISE_AND' => -109,
4926             'OP06_REGEX_BIND' => 251
4927             }
4928             },
4929             {#State 319
4930             DEFAULT => -104
4931             },
4932             {#State 320
4933             DEFAULT => -242
4934             },
4935             {#State 321
4936             ACTIONS => {
4937             'COLON' => 366
4938             }
4939             },
4940             {#State 322
4941             DEFAULT => -241
4942             },
4943             {#State 323
4944             ACTIONS => {
4945             'OP04_MATH_POW' => 247,
4946             'OP23_LOGICAL_AND' => -117,
4947             "]" => -117,
4948             'OP08_STRING_CAT' => 245,
4949             'OP08_MATH_ADD_SUB' => 244,
4950             'OP16_LOGICAL_OR' => -117,
4951             ")" => -117,
4952             'OP18_TERNARY' => -117,
4953             'OP13_BITWISE_AND' => 243,
4954             'OP06_REGEX_BIND' => 251,
4955             'OP24_LOGICAL_OR_XOR' => -117,
4956             "}" => -117,
4957             'OP17_LIST_RANGE' => -117,
4958             'OP09_BITWISE_SHIFT' => 250,
4959             'OP07_MATH_MULT_DIV_MOD' => 240,
4960             'OP11_COMPARE_LT_GT' => 249,
4961             ";" => -117,
4962             'OP21_LIST_COMMA' => -117,
4963             'OP12_COMPARE_EQ_NE' => 239,
4964             'OP14_BITWISE_OR_XOR' => 237,
4965             'OP07_STRING_REPEAT' => 238,
4966             'OP15_LOGICAL_AND' => 248
4967             }
4968             },
4969             {#State 324
4970             ACTIONS => {
4971             'OP17_LIST_RANGE' => 241,
4972             'OP24_LOGICAL_OR_XOR' => 242,
4973             'OP07_STRING_REPEAT' => 238,
4974             'OP15_LOGICAL_AND' => 248,
4975             'OP14_BITWISE_OR_XOR' => 237,
4976             ";" => -158,
4977             'OP11_COMPARE_LT_GT' => 249,
4978             'OP09_BITWISE_SHIFT' => 250,
4979             'OP07_MATH_MULT_DIV_MOD' => 240,
4980             'OP12_COMPARE_EQ_NE' => 239,
4981             'OP08_MATH_ADD_SUB' => 244,
4982             'OP08_STRING_CAT' => 245,
4983             'OP04_MATH_POW' => 247,
4984             'OP23_LOGICAL_AND' => 246,
4985             'OP18_TERNARY' => 252,
4986             'OP13_BITWISE_AND' => 243,
4987             'OP06_REGEX_BIND' => 251,
4988             'OP16_LOGICAL_OR' => 253,
4989             ")" => -158
4990             }
4991             },
4992             {#State 325
4993             DEFAULT => -159
4994             },
4995             {#State 326
4996             DEFAULT => -160
4997             },
4998             {#State 327
4999             DEFAULT => -199
5000             },
5001             {#State 328
5002             ACTIONS => {
5003             'OP11_COMPARE_LT_GT' => 249,
5004             'OP09_BITWISE_SHIFT' => 250,
5005             'OP07_MATH_MULT_DIV_MOD' => 240,
5006             ";" => -200,
5007             'OP12_COMPARE_EQ_NE' => 239,
5008             'OP15_LOGICAL_AND' => 248,
5009             'OP07_STRING_REPEAT' => 238,
5010             'OP14_BITWISE_OR_XOR' => 237,
5011             'OP24_LOGICAL_OR_XOR' => 242,
5012             'OP17_LIST_RANGE' => 241,
5013             'OP16_LOGICAL_OR' => 253,
5014             ")" => -200,
5015             'OP18_TERNARY' => 252,
5016             'OP13_BITWISE_AND' => 243,
5017             'OP06_REGEX_BIND' => 251,
5018             'OP04_MATH_POW' => 247,
5019             'OP23_LOGICAL_AND' => 246,
5020             'OP08_STRING_CAT' => 245,
5021             'OP08_MATH_ADD_SUB' => 244
5022             }
5023             },
5024             {#State 329
5025             ACTIONS => {
5026             "undef" => 104,
5027             'VARIABLE_SYMBOL' => 103,
5028             'OP22_LOGICAL_NEG_LPAREN' => 106,
5029             ")" => -140,
5030             'WORD_SCOPED' => 25,
5031             'OP10_NAMED_UNARY' => 109,
5032             'SELF' => 143,
5033             'OP01_QW' => 167,
5034             'OP22_LOGICAL_NEG' => 110,
5035             "%{" => 114,
5036             'OP03_MATH_INC_DEC' => 115,
5037             'CONSTANT_CALL_SCOPED' => 116,
5038             'ARGV' => 166,
5039             'OP05_LOGICAL_NEG' => 120,
5040             'OP01_CLOSE' => 93,
5041             'OP01_OPEN' => 92,
5042             'WORD' => 24,
5043             'LITERAL_STRING' => 123,
5044             'OP05_BITWISE_NEG_LPAREN' => 122,
5045             'OP01_NAMED' => 165,
5046             'LITERAL_NUMBER' => 98,
5047             'OP05_MATH_NEG_LPAREN' => 124,
5048             'LBRACKET' => 125,
5049             'WORD_UPPERCASE' => 161,
5050             'LPAREN' => 130,
5051             "\@{" => 99,
5052             'MY' => 160,
5053             'LBRACE' => 100
5054             },
5055             GOTOS => {
5056             'HashReference' => 126,
5057             'Literal' => 128,
5058             'Operator' => 111,
5059             'ListElements' => 368,
5060             'ArrayReference' => 134,
5061             'Expression' => 159,
5062             'Variable' => 164,
5063             'TypeInner' => 163,
5064             'WordScoped' => 140,
5065             'ArrayDereference' => 139,
5066             'OPTIONAL-41' => 367,
5067             'ListElement' => 209,
5068             'HashDereference' => 142,
5069             'VariableSymbolOrSelf' => 108,
5070             'SubExpression' => 210
5071             }
5072             },
5073             {#State 330
5074             ACTIONS => {
5075             'LBRACE' => 369
5076             }
5077             },
5078             {#State 331
5079             ACTIONS => {
5080             'SUB' => 371,
5081             'LITERAL_NUMBER' => 370
5082             },
5083             GOTOS => {
5084             'Subroutine' => 372,
5085             'SubroutineOrMethod' => 373,
5086             'Method' => 374
5087             }
5088             },
5089             {#State 332
5090             ACTIONS => {
5091             'OP19_VARIABLE_ASSIGN' => 375
5092             }
5093             },
5094             {#State 333
5095             ACTIONS => {
5096             "}" => 376
5097             }
5098             },
5099             {#State 334
5100             ACTIONS => {
5101             'OP21_LIST_COMMA' => 377
5102             }
5103             },
5104             {#State 335
5105             ACTIONS => {
5106             ";" => 378
5107             }
5108             },
5109             {#State 336
5110             ACTIONS => {
5111             'OP01_PRINT' => 191,
5112             'OP19_LOOP_CONTROL_SCOLON' => 178,
5113             'OP01_NAMED_VOID' => 192,
5114             'OP10_NAMED_UNARY' => 193,
5115             'OP22_LOGICAL_NEG' => 195,
5116             'OP08_MATH_ADD_SUB' => 180,
5117             'OP23_LOGICAL_AND' => 181,
5118             'OP07_STRING_REPEAT' => 171,
5119             'OP01_CLOSE' => 185,
5120             'OP01_OPEN' => 184,
5121             'WORD' => 173,
5122             'OP19_LOOP_CONTROL' => 187,
5123             'OP12_COMPARE_EQ_NE' => 172,
5124             'OP11_COMPARE_LT_GT' => 188,
5125             'OP07_MATH_MULT_DIV_MOD' => 174,
5126             'OP01_NAMED' => 189,
5127             'OP24_LOGICAL_OR_XOR' => 177
5128             },
5129             GOTOS => {
5130             'OpStringOrWord' => 379
5131             }
5132             },
5133             {#State 337
5134             DEFAULT => -215
5135             },
5136             {#State 338
5137             DEFAULT => -216
5138             },
5139             {#State 339
5140             ACTIONS => {
5141             'OP01_CLOSE' => 93,
5142             'OP05_LOGICAL_NEG' => 120,
5143             'OP01_OPEN' => 92,
5144             'LITERAL_STRING' => 123,
5145             'OP05_BITWISE_NEG_LPAREN' => 122,
5146             'OP01_NAMED' => 165,
5147             'LITERAL_NUMBER' => 98,
5148             'WORD' => 24,
5149             "\@{" => 99,
5150             'WORD_UPPERCASE' => 161,
5151             'LPAREN' => 130,
5152             'OP05_MATH_NEG_LPAREN' => 124,
5153             'LBRACKET' => 125,
5154             'LBRACE' => 100,
5155             'VARIABLE_SYMBOL' => 103,
5156             "undef" => 104,
5157             'OP10_NAMED_UNARY' => 109,
5158             'WORD_SCOPED' => 25,
5159             'OP22_LOGICAL_NEG_LPAREN' => 106,
5160             'OP22_LOGICAL_NEG' => 110,
5161             'SELF' => 143,
5162             'CONSTANT_CALL_SCOPED' => 116,
5163             "%{" => 114,
5164             'OP03_MATH_INC_DEC' => 115
5165             },
5166             GOTOS => {
5167             'SubExpression' => 380,
5168             'HashDereference' => 142,
5169             'VariableSymbolOrSelf' => 108,
5170             'ArrayDereference' => 139,
5171             'WordScoped' => 140,
5172             'Variable' => 164,
5173             'Expression' => 159,
5174             'ArrayReference' => 134,
5175             'Literal' => 128,
5176             'Operator' => 111,
5177             'HashReference' => 126
5178             }
5179             },
5180             {#State 340
5181             DEFAULT => -223
5182             },
5183             {#State 341
5184             ACTIONS => {
5185             'OP08_MATH_ADD_SUB' => 180,
5186             'OP22_LOGICAL_NEG' => 195,
5187             'SELF' => 143,
5188             'OP23_LOGICAL_AND' => 181,
5189             "%{" => 114,
5190             'OP19_LOOP_CONTROL_SCOLON' => 178,
5191             'VARIABLE_SYMBOL' => 103,
5192             'OP01_PRINT' => 191,
5193             'OP10_NAMED_UNARY' => 193,
5194             'OP01_NAMED_VOID' => 192,
5195             'OP24_LOGICAL_OR_XOR' => 177,
5196             'OP01_CLOSE' => 185,
5197             'OP07_STRING_REPEAT' => 171,
5198             'OP01_OPEN' => 184,
5199             'LITERAL_NUMBER' => 98,
5200             'LITERAL_STRING' => 123,
5201             'OP07_MATH_MULT_DIV_MOD' => 174,
5202             'OP11_COMPARE_LT_GT' => 188,
5203             'OP01_NAMED' => 189,
5204             'OP12_COMPARE_EQ_NE' => 172,
5205             'ENV' => 186,
5206             'OP19_LOOP_CONTROL' => 187,
5207             'WORD' => 173
5208             },
5209             GOTOS => {
5210             'OpStringOrWord' => 194,
5211             'VarOrLitOrOpStrOrWord' => 183,
5212             'Literal' => 176,
5213             'HashDereference' => 179,
5214             'VariableSymbolOrSelf' => 108,
5215             'HashEntry' => 381,
5216             'Variable' => 182
5217             }
5218             },
5219             {#State 342
5220             DEFAULT => -225
5221             },
5222             {#State 343
5223             ACTIONS => {
5224             'OP11_COMPARE_LT_GT' => 249,
5225             'OP07_MATH_MULT_DIV_MOD' => 240,
5226             'OP09_BITWISE_SHIFT' => 250,
5227             'OP12_COMPARE_EQ_NE' => 239,
5228             'OP15_LOGICAL_AND' => 248,
5229             'OP07_STRING_REPEAT' => 238,
5230             'OP14_BITWISE_OR_XOR' => 237,
5231             'OP24_LOGICAL_OR_XOR' => 242,
5232             'OP17_LIST_RANGE' => 241,
5233             'OP16_LOGICAL_OR' => 253,
5234             ")" => 382,
5235             'OP18_TERNARY' => 252,
5236             'OP13_BITWISE_AND' => 243,
5237             'OP06_REGEX_BIND' => 251,
5238             'OP04_MATH_POW' => 247,
5239             'OP23_LOGICAL_AND' => 246,
5240             'OP08_STRING_CAT' => 245,
5241             'OP08_MATH_ADD_SUB' => 244
5242             }
5243             },
5244             {#State 344
5245             ACTIONS => {
5246             'VARIABLE_SYMBOL' => 383
5247             }
5248             },
5249             {#State 345
5250             ACTIONS => {
5251             'VARIABLE_SYMBOL' => 384
5252             }
5253             },
5254             {#State 346
5255             ACTIONS => {
5256             'VARIABLE_SYMBOL' => 385
5257             }
5258             },
5259             {#State 347
5260             ACTIONS => {
5261             'VARIABLE_SYMBOL' => 386
5262             }
5263             },
5264             {#State 348
5265             DEFAULT => -130
5266             },
5267             {#State 349
5268             DEFAULT => -129
5269             },
5270             {#State 350
5271             ACTIONS => {
5272             'WORD' => 24,
5273             'OP01_NAMED' => 165,
5274             'OP05_BITWISE_NEG_LPAREN' => 122,
5275             'LITERAL_STRING' => 123,
5276             'LITERAL_NUMBER' => 98,
5277             'OP01_CLOSE' => 93,
5278             'OP05_LOGICAL_NEG' => 120,
5279             'OP01_OPEN' => 92,
5280             'LBRACE' => 100,
5281             'OP05_MATH_NEG_LPAREN' => 124,
5282             'LBRACKET' => 125,
5283             "\@{" => 99,
5284             'WORD_UPPERCASE' => 161,
5285             'LPAREN' => 130,
5286             'MY' => 160,
5287             'WORD_SCOPED' => 25,
5288             'OP22_LOGICAL_NEG_LPAREN' => 106,
5289             'OP10_NAMED_UNARY' => 109,
5290             'VARIABLE_SYMBOL' => 103,
5291             "undef" => 104,
5292             'OP03_MATH_INC_DEC' => 115,
5293             "%{" => 114,
5294             'CONSTANT_CALL_SCOPED' => 116,
5295             'ARGV' => 166,
5296             'SELF' => 143,
5297             'OP01_QW' => 167,
5298             'OP22_LOGICAL_NEG' => 110
5299             },
5300             GOTOS => {
5301             'SubExpression' => 210,
5302             'VariableSymbolOrSelf' => 108,
5303             'ListElement' => 387,
5304             'HashDereference' => 142,
5305             'TypeInner' => 163,
5306             'WordScoped' => 140,
5307             'ArrayDereference' => 139,
5308             'ArrayReference' => 134,
5309             'Expression' => 159,
5310             'Variable' => 164,
5311             'HashReference' => 126,
5312             'Literal' => 128,
5313             'Operator' => 111
5314             }
5315             },
5316             {#State 351
5317             DEFAULT => -202
5318             },
5319             {#State 352
5320             ACTIONS => {
5321             'OP17_LIST_RANGE' => 241,
5322             "}" => 388,
5323             'OP24_LOGICAL_OR_XOR' => 242,
5324             'OP15_LOGICAL_AND' => 248,
5325             'OP14_BITWISE_OR_XOR' => 237,
5326             'OP07_STRING_REPEAT' => 238,
5327             'OP12_COMPARE_EQ_NE' => 239,
5328             'OP11_COMPARE_LT_GT' => 249,
5329             'OP07_MATH_MULT_DIV_MOD' => 240,
5330             'OP09_BITWISE_SHIFT' => 250,
5331             'OP08_MATH_ADD_SUB' => 244,
5332             'OP08_STRING_CAT' => 245,
5333             'OP23_LOGICAL_AND' => 246,
5334             'OP04_MATH_POW' => 247,
5335             'OP13_BITWISE_AND' => 243,
5336             'OP06_REGEX_BIND' => 251,
5337             'OP18_TERNARY' => 252,
5338             'OP16_LOGICAL_OR' => 253
5339             }
5340             },
5341             {#State 353
5342             ACTIONS => {
5343             'LPAREN' => -231,
5344             "}" => 389,
5345             'OP02_METHOD_THINARROW_NEW' => -231
5346             }
5347             },
5348             {#State 354
5349             ACTIONS => {
5350             'OP04_MATH_POW' => 247,
5351             'OP23_LOGICAL_AND' => 246,
5352             "]" => 390,
5353             'OP08_STRING_CAT' => 245,
5354             'OP08_MATH_ADD_SUB' => 244,
5355             'OP16_LOGICAL_OR' => 253,
5356             'OP18_TERNARY' => 252,
5357             'OP13_BITWISE_AND' => 243,
5358             'OP06_REGEX_BIND' => 251,
5359             'OP24_LOGICAL_OR_XOR' => 242,
5360             'OP17_LIST_RANGE' => 241,
5361             'OP11_COMPARE_LT_GT' => 249,
5362             'OP07_MATH_MULT_DIV_MOD' => 240,
5363             'OP09_BITWISE_SHIFT' => 250,
5364             'OP12_COMPARE_EQ_NE' => 239,
5365             'OP14_BITWISE_OR_XOR' => 237,
5366             'OP07_STRING_REPEAT' => 238,
5367             'OP15_LOGICAL_AND' => 248
5368             }
5369             },
5370             {#State 355
5371             DEFAULT => -132
5372             },
5373             {#State 356
5374             DEFAULT => -230
5375             },
5376             {#State 357
5377             ACTIONS => {
5378             ")" => 391
5379             }
5380             },
5381             {#State 358
5382             ACTIONS => {
5383             'LPAREN' => 130,
5384             'WORD_UPPERCASE' => 161,
5385             "\@{" => 99,
5386             'MY' => 160,
5387             'LBRACKET' => 125,
5388             'OP05_MATH_NEG_LPAREN' => 124,
5389             'LBRACE' => 100,
5390             'OP01_OPEN' => 92,
5391             'OP05_LOGICAL_NEG' => 120,
5392             'OP01_CLOSE' => 93,
5393             'OP05_BITWISE_NEG_LPAREN' => 122,
5394             'OP01_NAMED' => 165,
5395             'LITERAL_STRING' => 123,
5396             'LITERAL_NUMBER' => 98,
5397             'WORD' => 24,
5398             'OP22_LOGICAL_NEG' => 110,
5399             'SELF' => 143,
5400             'OP01_QW' => 167,
5401             'ARGV' => 166,
5402             "%{" => 114,
5403             'CONSTANT_CALL_SCOPED' => 116,
5404             'OP03_MATH_INC_DEC' => 115,
5405             "undef" => 104,
5406             'VARIABLE_SYMBOL' => 103,
5407             'OP10_NAMED_UNARY' => 109,
5408             'WORD_SCOPED' => 25,
5409             'OP22_LOGICAL_NEG_LPAREN' => 106
5410             },
5411             GOTOS => {
5412             'HashReference' => 126,
5413             'Literal' => 128,
5414             'Operator' => 111,
5415             'ListElements' => 392,
5416             'ArrayReference' => 134,
5417             'Expression' => 159,
5418             'Variable' => 164,
5419             'WordScoped' => 140,
5420             'ArrayDereference' => 139,
5421             'TypeInner' => 163,
5422             'SubExpression' => 210,
5423             'HashDereference' => 142,
5424             'ListElement' => 209,
5425             'VariableSymbolOrSelf' => 108
5426             }
5427             },
5428             {#State 359
5429             ACTIONS => {
5430             'LPAREN' => 130,
5431             'WORD_UPPERCASE' => 161,
5432             "\@{" => 99,
5433             'OP10_NAMED_UNARY_SCOLON' => 395,
5434             'LBRACKET' => 125,
5435             'OP05_MATH_NEG_LPAREN' => 124,
5436             'LBRACE' => 100,
5437             'OP01_OPEN' => 92,
5438             'OP05_LOGICAL_NEG' => 120,
5439             'OP01_CLOSE' => 93,
5440             'OP01_NAMED' => 165,
5441             'OP05_BITWISE_NEG_LPAREN' => 122,
5442             'LITERAL_STRING' => 123,
5443             'LITERAL_NUMBER' => 98,
5444             'WORD' => 24,
5445             'OP22_LOGICAL_NEG' => 110,
5446             'OP01_NAMED_SCOLON' => 394,
5447             'SELF' => 143,
5448             'FHREF_SYMBOL_IN' => 325,
5449             "%{" => 114,
5450             'CONSTANT_CALL_SCOPED' => 116,
5451             'OP03_MATH_INC_DEC' => 115,
5452             'VARIABLE_SYMBOL' => 103,
5453             "undef" => 104,
5454             'STDIN' => 326,
5455             'OP10_NAMED_UNARY' => 109,
5456             'WORD_SCOPED' => 25,
5457             'OP22_LOGICAL_NEG_LPAREN' => 106
5458             },
5459             GOTOS => {
5460             'Expression' => 159,
5461             'ArrayReference' => 134,
5462             'Variable' => 164,
5463             'HashReference' => 126,
5464             'OpNamedScolonOrSubExpIn' => 396,
5465             'SubExpressionOrInput' => 393,
5466             'Literal' => 128,
5467             'Operator' => 111,
5468             'VariableSymbolOrSelf' => 108,
5469             'HashDereference' => 142,
5470             'SubExpression' => 324,
5471             'ArrayDereference' => 139,
5472             'WordScoped' => 140
5473             }
5474             },
5475             {#State 360
5476             ACTIONS => {
5477             'LBRACE' => 100,
5478             "\@{" => 99,
5479             'LPAREN' => 130,
5480             'WORD_UPPERCASE' => 161,
5481             'LBRACKET' => 125,
5482             'OP05_MATH_NEG_LPAREN' => 124,
5483             'LITERAL_NUMBER' => 98,
5484             'OP01_NAMED' => 165,
5485             'OP05_BITWISE_NEG_LPAREN' => 122,
5486             'LITERAL_STRING' => 123,
5487             'WORD' => 24,
5488             'OP05_LOGICAL_NEG' => 120,
5489             'OP01_CLOSE' => 93,
5490             'OP01_OPEN' => 92,
5491             'CONSTANT_CALL_SCOPED' => 116,
5492             'OP03_MATH_INC_DEC' => 115,
5493             "%{" => 114,
5494             'OP22_LOGICAL_NEG' => 110,
5495             'SELF' => 143,
5496             'OP10_NAMED_UNARY' => 109,
5497             'WORD_SCOPED' => 25,
5498             'OP22_LOGICAL_NEG_LPAREN' => 106,
5499             'VARIABLE_SYMBOL' => 103,
5500             "undef" => 104
5501             },
5502             GOTOS => {
5503             'HashReference' => 126,
5504             'Literal' => 128,
5505             'Operator' => 111,
5506             'ArrayReference' => 134,
5507             'Expression' => 159,
5508             'Variable' => 164,
5509             'ArrayDereference' => 139,
5510             'WordScoped' => 140,
5511             'SubExpression' => 397,
5512             'HashDereference' => 142,
5513             'VariableSymbolOrSelf' => 108
5514             }
5515             },
5516             {#State 361
5517             DEFAULT => -195
5518             },
5519             {#State 362
5520             DEFAULT => -198
5521             },
5522             {#State 363
5523             ACTIONS => {
5524             'LBRACE' => 398
5525             },
5526             GOTOS => {
5527             'CodeBlock' => 399
5528             }
5529             },
5530             {#State 364
5531             DEFAULT => -146
5532             },
5533             {#State 365
5534             DEFAULT => -148
5535             },
5536             {#State 366
5537             ACTIONS => {
5538             'SELF' => 143,
5539             'VARIABLE_SYMBOL' => 103,
5540             'LITERAL_STRING' => 123,
5541             'LITERAL_NUMBER' => 98
5542             },
5543             GOTOS => {
5544             'VariableSymbolOrSelf' => 108,
5545             'VariableOrLiteral' => 400,
5546             'Variable' => 322,
5547             'Literal' => 320
5548             }
5549             },
5550             {#State 367
5551             ACTIONS => {
5552             ")" => 401
5553             }
5554             },
5555             {#State 368
5556             DEFAULT => -139
5557             },
5558             {#State 369
5559             ACTIONS => {
5560             'OP23_LOGICAL_AND' => 181,
5561             'OP08_MATH_ADD_SUB' => 180,
5562             'OP22_LOGICAL_NEG' => 195,
5563             'OP01_NAMED_VOID' => 192,
5564             'OP10_NAMED_UNARY' => 193,
5565             'OP19_LOOP_CONTROL_SCOLON' => 178,
5566             'OP01_PRINT' => 191,
5567             'OP24_LOGICAL_OR_XOR' => 177,
5568             "}" => 403,
5569             'OP12_COMPARE_EQ_NE' => 172,
5570             'OP19_LOOP_CONTROL' => 187,
5571             'WORD' => 173,
5572             'OP01_NAMED' => 189,
5573             'OP07_MATH_MULT_DIV_MOD' => 174,
5574             'OP11_COMPARE_LT_GT' => 188,
5575             'OP07_STRING_REPEAT' => 171,
5576             'OP01_CLOSE' => 185,
5577             'OP01_OPEN' => 184
5578             },
5579             GOTOS => {
5580             'OpStringOrWord' => 402,
5581             'HashEntryProperties' => 404
5582             }
5583             },
5584             {#State 370
5585             ACTIONS => {
5586             ";" => 405
5587             }
5588             },
5589             {#State 371
5590             ACTIONS => {
5591             'WORD' => 406
5592             }
5593             },
5594             {#State 372
5595             DEFAULT => -87
5596             },
5597             {#State 373
5598             DEFAULT => -70
5599             },
5600             {#State 374
5601             DEFAULT => -88
5602             },
5603             {#State 375
5604             DEFAULT => -240
5605             },
5606             {#State 376
5607             ACTIONS => {
5608             ";" => 407
5609             }
5610             },
5611             {#State 377
5612             ACTIONS => {
5613             'LITERAL_STRING' => 408
5614             }
5615             },
5616             {#State 378
5617             DEFAULT => -134
5618             },
5619             {#State 379
5620             ACTIONS => {
5621             'OP19_VARIABLE_ASSIGN' => 409
5622             }
5623             },
5624             {#State 380
5625             ACTIONS => {
5626             'OP21_LIST_COMMA' => -218,
5627             'OP12_COMPARE_EQ_NE' => 239,
5628             'OP07_MATH_MULT_DIV_MOD' => 240,
5629             'OP09_BITWISE_SHIFT' => 250,
5630             'OP11_COMPARE_LT_GT' => 249,
5631             'OP14_BITWISE_OR_XOR' => 237,
5632             'OP07_STRING_REPEAT' => 238,
5633             'OP15_LOGICAL_AND' => 248,
5634             'OP24_LOGICAL_OR_XOR' => 242,
5635             'OP17_LIST_RANGE' => 241,
5636             "}" => -218,
5637             'OP16_LOGICAL_OR' => 253,
5638             'OP06_REGEX_BIND' => 251,
5639             'OP13_BITWISE_AND' => 243,
5640             'OP18_TERNARY' => 252,
5641             'OP23_LOGICAL_AND' => 246,
5642             'OP04_MATH_POW' => 247,
5643             'OP08_STRING_CAT' => 245,
5644             'OP08_MATH_ADD_SUB' => 244
5645             }
5646             },
5647             {#State 381
5648             DEFAULT => -222
5649             },
5650             {#State 382
5651             ACTIONS => {
5652             'LBRACE' => 398
5653             },
5654             GOTOS => {
5655             'CodeBlock' => 410
5656             }
5657             },
5658             {#State 383
5659             ACTIONS => {
5660             'OP19_VARIABLE_ASSIGN' => 411
5661             }
5662             },
5663             {#State 384
5664             ACTIONS => {
5665             'OP19_VARIABLE_ASSIGN' => 412
5666             }
5667             },
5668             {#State 385
5669             ACTIONS => {
5670             'LPAREN' => 413
5671             }
5672             },
5673             {#State 386
5674             ACTIONS => {
5675             'LPAREN' => 414
5676             }
5677             },
5678             {#State 387
5679             DEFAULT => -201
5680             },
5681             {#State 388
5682             DEFAULT => -193
5683             },
5684             {#State 389
5685             DEFAULT => -194
5686             },
5687             {#State 390
5688             DEFAULT => -192
5689             },
5690             {#State 391
5691             DEFAULT => -93
5692             },
5693             {#State 392
5694             ACTIONS => {
5695             ")" => 415
5696             }
5697             },
5698             {#State 393
5699             ACTIONS => {
5700             ";" => 416
5701             }
5702             },
5703             {#State 394
5704             DEFAULT => -253
5705             },
5706             {#State 395
5707             DEFAULT => -254
5708             },
5709             {#State 396
5710             DEFAULT => -196
5711             },
5712             {#State 397
5713             ACTIONS => {
5714             'OP23_LOGICAL_AND' => 246,
5715             'OP04_MATH_POW' => 247,
5716             'OP08_STRING_CAT' => 245,
5717             "]" => 417,
5718             'OP08_MATH_ADD_SUB' => 244,
5719             'OP16_LOGICAL_OR' => 253,
5720             'OP13_BITWISE_AND' => 243,
5721             'OP06_REGEX_BIND' => 251,
5722             'OP18_TERNARY' => 252,
5723             'OP24_LOGICAL_OR_XOR' => 242,
5724             'OP17_LIST_RANGE' => 241,
5725             'OP12_COMPARE_EQ_NE' => 239,
5726             'OP11_COMPARE_LT_GT' => 249,
5727             'OP07_MATH_MULT_DIV_MOD' => 240,
5728             'OP09_BITWISE_SHIFT' => 250,
5729             'OP07_STRING_REPEAT' => 238,
5730             'OP14_BITWISE_OR_XOR' => 237,
5731             'OP15_LOGICAL_AND' => 248
5732             }
5733             },
5734             {#State 398
5735             ACTIONS => {
5736             'SELF' => 143,
5737             "for" => -165,
5738             "while" => -165,
5739             'OP19_LOOP_CONTROL_SCOLON' => 138,
5740             'OP05_MATH_NEG_LPAREN' => 124,
5741             'LBRACKET' => 125,
5742             'LPAREN' => 130,
5743             'WORD_UPPERCASE' => 129,
5744             'MY' => 132,
5745             'OP10_NAMED_UNARY_SCOLON' => 131,
5746             'OP01_NAMED_VOID_SCOLON' => 133,
5747             "if" => 136,
5748             'OP05_LOGICAL_NEG' => 120,
5749             'WORD' => 24,
5750             "foreach" => -165,
5751             'OP05_BITWISE_NEG_LPAREN' => 122,
5752             'LITERAL_STRING' => 123,
5753             'OP22_LOGICAL_NEG' => 110,
5754             'OP01_NAMED_VOID_LPAREN' => 112,
5755             'OP01_NAMED_SCOLON' => 113,
5756             "%{" => 114,
5757             'OP03_MATH_INC_DEC' => 115,
5758             'CONSTANT_CALL_SCOPED' => 116,
5759             'VARIABLE_SYMBOL' => 103,
5760             "undef" => 104,
5761             'OP01_PRINT' => 102,
5762             'WORD_SCOPED' => 25,
5763             'OP22_LOGICAL_NEG_LPAREN' => 106,
5764             'OP01_NAMED_VOID' => 107,
5765             'OP10_NAMED_UNARY' => 109,
5766             "\@{" => 99,
5767             'LBRACE' => 100,
5768             'OP01_CLOSE' => 93,
5769             'OP01_OPEN' => 92,
5770             'OP19_LOOP_CONTROL' => 96,
5771             'OP01_NAMED' => 97,
5772             'LITERAL_NUMBER' => 98
5773             },
5774             GOTOS => {
5775             'VariableSymbolOrSelf' => 108,
5776             'HashDereference' => 142,
5777             'SubExpression' => 141,
5778             'WordScoped' => 140,
5779             'ArrayDereference' => 139,
5780             'Statement' => 137,
5781             'Variable' => 145,
5782             'Operation' => 418,
5783             'LoopLabel' => 144,
5784             'Operator' => 111,
5785             'VariableModification' => 121,
5786             'VariableDeclaration' => 94,
5787             'OperatorVoid' => 95,
5788             'Conditional' => 118,
5789             'PAREN-43' => 119,
5790             'OPTIONAL-44' => 101,
5791             'PLUS-49' => 419,
5792             'ArrayReference' => 134,
5793             'Expression' => 135,
5794             'Literal' => 128,
5795             'HashReference' => 126
5796             }
5797             },
5798             {#State 399
5799             DEFAULT => -173,
5800             GOTOS => {
5801             'STAR-46' => 420
5802             }
5803             },
5804             {#State 400
5805             DEFAULT => -119
5806             },
5807             {#State 401
5808             DEFAULT => -147
5809             },
5810             {#State 402
5811             ACTIONS => {
5812             'OP20_HASH_FATARROW' => 421
5813             }
5814             },
5815             {#State 403
5816             ACTIONS => {
5817             ";" => 422
5818             }
5819             },
5820             {#State 404
5821             DEFAULT => -75,
5822             GOTOS => {
5823             'STAR-32' => 423
5824             }
5825             },
5826             {#State 405
5827             DEFAULT => -72
5828             },
5829             {#State 406
5830             ACTIONS => {
5831             'LBRACE' => 424
5832             }
5833             },
5834             {#State 407
5835             ACTIONS => {
5836             "while" => -54,
5837             "for" => -54,
5838             'SELF' => -54,
5839             'OP19_LOOP_CONTROL_SCOLON' => -54,
5840             'OP01_NAMED_VOID_SCOLON' => -54,
5841             "if" => -54,
5842             'LBRACKET' => -54,
5843             'OP05_MATH_NEG_LPAREN' => -54,
5844             'MY' => -54,
5845             'OP10_NAMED_UNARY_SCOLON' => -54,
5846             'WORD_UPPERCASE' => -54,
5847             "}" => -54,
5848             'LPAREN' => -54,
5849             "foreach" => -54,
5850             'WORD' => -54,
5851             'OP05_BITWISE_NEG_LPAREN' => -54,
5852             'LITERAL_STRING' => -54,
5853             'OP05_LOGICAL_NEG' => -54,
5854             'OP03_MATH_INC_DEC' => -54,
5855             'LPAREN_MY' => 427,
5856             'CONSTANT_CALL_SCOPED' => -54,
5857             "%{" => -54,
5858             'OP01_NAMED_VOID_LPAREN' => -54,
5859             'OP01_NAMED_SCOLON' => -54,
5860             'OP22_LOGICAL_NEG' => -54,
5861             'OP01_NAMED_VOID' => -54,
5862             'OP22_LOGICAL_NEG_LPAREN' => -54,
5863             'WORD_SCOPED' => -54,
5864             'OP10_NAMED_UNARY' => -54,
5865             'OP01_PRINT' => -54,
5866             'VARIABLE_SYMBOL' => -54,
5867             "undef" => -54,
5868             'LBRACE' => -54,
5869             "\@{" => -54,
5870             'OP19_LOOP_CONTROL' => -54,
5871             'LITERAL_NUMBER' => -54,
5872             'OP01_NAMED' => -54,
5873             'OP01_CLOSE' => -54,
5874             'OP01_OPEN' => -54
5875             },
5876             GOTOS => {
5877             'SubroutineArguments' => 425,
5878             'OPTIONAL-22' => 426
5879             }
5880             },
5881             {#State 408
5882             ACTIONS => {
5883             'OP21_LIST_COMMA' => 428
5884             }
5885             },
5886             {#State 409
5887             DEFAULT => -237
5888             },
5889             {#State 410
5890             DEFAULT => -184
5891             },
5892             {#State 411
5893             ACTIONS => {
5894             'LBRACE' => 100,
5895             'LBRACKET' => 125,
5896             'OP05_MATH_NEG_LPAREN' => 124,
5897             "\@{" => 99,
5898             'LPAREN' => 130,
5899             'WORD_UPPERCASE' => 161,
5900             'WORD' => 24,
5901             'LITERAL_NUMBER' => 98,
5902             'OP05_BITWISE_NEG_LPAREN' => 122,
5903             'LITERAL_STRING' => 123,
5904             'OP01_NAMED' => 165,
5905             'OP01_CLOSE' => 93,
5906             'OP05_LOGICAL_NEG' => 120,
5907             'OP01_OPEN' => 92,
5908             'CONSTANT_CALL_SCOPED' => 116,
5909             "%{" => 114,
5910             'OP03_MATH_INC_DEC' => 115,
5911             'FHREF_SYMBOL_IN' => 325,
5912             'SELF' => 143,
5913             'OP22_LOGICAL_NEG' => 110,
5914             'OP22_LOGICAL_NEG_LPAREN' => 106,
5915             'WORD_SCOPED' => 25,
5916             'OP10_NAMED_UNARY' => 109,
5917             'STDIN' => 326,
5918             "undef" => 104,
5919             'VARIABLE_SYMBOL' => 103
5920             },
5921             GOTOS => {
5922             'SubExpressionOrInput' => 429,
5923             'Literal' => 128,
5924             'Operator' => 111,
5925             'HashReference' => 126,
5926             'Variable' => 164,
5927             'ArrayReference' => 134,
5928             'Expression' => 159,
5929             'WordScoped' => 140,
5930             'ArrayDereference' => 139,
5931             'VariableSymbolOrSelf' => 108,
5932             'HashDereference' => 142,
5933             'SubExpression' => 324
5934             }
5935             },
5936             {#State 412
5937             ACTIONS => {
5938             "%{" => 114,
5939             'CONSTANT_CALL_SCOPED' => 116,
5940             'OP03_MATH_INC_DEC' => 115,
5941             'OP01_NAMED_SCOLON' => 433,
5942             'OP22_LOGICAL_NEG' => 110,
5943             'SELF' => 143,
5944             'OP10_NAMED_UNARY' => 109,
5945             'WORD_SCOPED' => 25,
5946             'OP22_LOGICAL_NEG_LPAREN' => 106,
5947             'VARIABLE_SYMBOL' => 103,
5948             "undef" => 104,
5949             'LBRACE' => 100,
5950             'OP10_NAMED_UNARY_SCOLON' => 432,
5951             "\@{" => 99,
5952             'WORD_UPPERCASE' => 161,
5953             'LPAREN' => 130,
5954             'LBRACKET' => 125,
5955             'OP05_MATH_NEG_LPAREN' => 124,
5956             'LITERAL_NUMBER' => 98,
5957             'LITERAL_STRING' => 123,
5958             'OP01_NAMED' => 165,
5959             'OP05_BITWISE_NEG_LPAREN' => 122,
5960             'WORD' => 24,
5961             'OP01_CLOSE' => 93,
5962             'OP01_OPEN' => 92,
5963             'OP05_LOGICAL_NEG' => 120
5964             },
5965             GOTOS => {
5966             'Variable' => 164,
5967             'ArrayReference' => 134,
5968             'Expression' => 159,
5969             'Operator' => 111,
5970             'Literal' => 128,
5971             'HashReference' => 126,
5972             'OpNamedScolonOrSubExp' => 430,
5973             'VariableSymbolOrSelf' => 108,
5974             'HashDereference' => 142,
5975             'SubExpression' => 431,
5976             'ArrayDereference' => 139,
5977             'WordScoped' => 140
5978             }
5979             },
5980             {#State 413
5981             ACTIONS => {
5982             'LITERAL_NUMBER' => 98,
5983             'OP05_BITWISE_NEG_LPAREN' => 122,
5984             'OP01_NAMED' => 165,
5985             'LITERAL_STRING' => 123,
5986             'WORD' => 24,
5987             'OP05_LOGICAL_NEG' => 120,
5988             'OP01_OPEN' => 92,
5989             'OP01_CLOSE' => 93,
5990             'LBRACE' => 100,
5991             'WORD_UPPERCASE' => 161,
5992             'LPAREN' => 130,
5993             "\@{" => 99,
5994             'OP05_MATH_NEG_LPAREN' => 124,
5995             'LBRACKET' => 125,
5996             'OP10_NAMED_UNARY' => 109,
5997             'OP22_LOGICAL_NEG_LPAREN' => 106,
5998             'WORD_SCOPED' => 25,
5999             "undef" => 104,
6000             'VARIABLE_SYMBOL' => 103,
6001             "%{" => 114,
6002             'CONSTANT_CALL_SCOPED' => 116,
6003             'OP03_MATH_INC_DEC' => 115,
6004             'OP22_LOGICAL_NEG' => 110,
6005             'SELF' => 143
6006             },
6007             GOTOS => {
6008             'ArrayReference' => 134,
6009             'Expression' => 159,
6010             'Variable' => 164,
6011             'HashReference' => 126,
6012             'Operator' => 111,
6013             'Literal' => 128,
6014             'VariableSymbolOrSelf' => 108,
6015             'HashDereference' => 142,
6016             'SubExpression' => 434,
6017             'WordScoped' => 140,
6018             'ArrayDereference' => 139
6019             }
6020             },
6021             {#State 414
6022             ACTIONS => {
6023             'WORD' => 24,
6024             'LITERAL_STRING' => 123,
6025             'OP05_BITWISE_NEG_LPAREN' => 122,
6026             'OP01_NAMED' => 165,
6027             'LITERAL_NUMBER' => 98,
6028             'OP01_CLOSE' => 93,
6029             'OP05_LOGICAL_NEG' => 120,
6030             'OP01_OPEN' => 92,
6031             'LBRACE' => 100,
6032             'OP05_MATH_NEG_LPAREN' => 124,
6033             'LBRACKET' => 125,
6034             'LPAREN' => 130,
6035             'WORD_UPPERCASE' => 161,
6036             "\@{" => 99,
6037             'MY' => 160,
6038             'WORD_SCOPED' => 25,
6039             'OP22_LOGICAL_NEG_LPAREN' => 106,
6040             'OP10_NAMED_UNARY' => 109,
6041             "undef" => 104,
6042             'VARIABLE_SYMBOL' => 103,
6043             'CONSTANT_CALL_SCOPED' => 116,
6044             'OP03_MATH_INC_DEC' => 115,
6045             "%{" => 114,
6046             'ARGV' => 166,
6047             'SELF' => 143,
6048             'OP01_QW' => 167,
6049             'OP22_LOGICAL_NEG' => 110
6050             },
6051             GOTOS => {
6052             'Expression' => 159,
6053             'ArrayReference' => 134,
6054             'Variable' => 164,
6055             'HashReference' => 126,
6056             'Literal' => 128,
6057             'Operator' => 111,
6058             'ListElements' => 435,
6059             'HashDereference' => 142,
6060             'ListElement' => 209,
6061             'VariableSymbolOrSelf' => 108,
6062             'SubExpression' => 210,
6063             'TypeInner' => 163,
6064             'WordScoped' => 140,
6065             'ArrayDereference' => 139
6066             }
6067             },
6068             {#State 415
6069             DEFAULT => -95
6070             },
6071             {#State 416
6072             DEFAULT => -255
6073             },
6074             {#State 417
6075             ACTIONS => {
6076             'OP19_VARIABLE_ASSIGN' => 436
6077             }
6078             },
6079             {#State 418
6080             DEFAULT => -187
6081             },
6082             {#State 419
6083             ACTIONS => {
6084             'OP22_LOGICAL_NEG' => 110,
6085             'OP01_NAMED_VOID_LPAREN' => 112,
6086             'OP01_NAMED_SCOLON' => 113,
6087             'CONSTANT_CALL_SCOPED' => 116,
6088             'OP03_MATH_INC_DEC' => 115,
6089             "%{" => 114,
6090             "undef" => 104,
6091             'VARIABLE_SYMBOL' => 103,
6092             'OP01_PRINT' => 102,
6093             'OP10_NAMED_UNARY' => 109,
6094             'WORD_SCOPED' => 25,
6095             'OP01_NAMED_VOID' => 107,
6096             'OP22_LOGICAL_NEG_LPAREN' => 106,
6097             "\@{" => 99,
6098             'LBRACE' => 100,
6099             'OP01_OPEN' => 92,
6100             'OP01_CLOSE' => 93,
6101             'OP01_NAMED' => 97,
6102             'LITERAL_NUMBER' => 98,
6103             'OP19_LOOP_CONTROL' => 96,
6104             'SELF' => 143,
6105             "for" => -165,
6106             "while" => -165,
6107             'OP19_LOOP_CONTROL_SCOLON' => 138,
6108             'WORD_UPPERCASE' => 129,
6109             "}" => 437,
6110             'LPAREN' => 130,
6111             'OP10_NAMED_UNARY_SCOLON' => 131,
6112             'MY' => 132,
6113             'OP05_MATH_NEG_LPAREN' => 124,
6114             'LBRACKET' => 125,
6115             "if" => 136,
6116             'OP01_NAMED_VOID_SCOLON' => 133,
6117             'OP05_LOGICAL_NEG' => 120,
6118             'LITERAL_STRING' => 123,
6119             'OP05_BITWISE_NEG_LPAREN' => 122,
6120             'WORD' => 24,
6121             "foreach" => -165
6122             },
6123             GOTOS => {
6124             'SubExpression' => 141,
6125             'VariableSymbolOrSelf' => 108,
6126             'HashDereference' => 142,
6127             'Statement' => 137,
6128             'WordScoped' => 140,
6129             'ArrayDereference' => 139,
6130             'LoopLabel' => 144,
6131             'Variable' => 145,
6132             'Operation' => 438,
6133             'Operator' => 111,
6134             'VariableModification' => 121,
6135             'PAREN-43' => 119,
6136             'Conditional' => 118,
6137             'OperatorVoid' => 95,
6138             'VariableDeclaration' => 94,
6139             'Expression' => 135,
6140             'ArrayReference' => 134,
6141             'OPTIONAL-44' => 101,
6142             'HashReference' => 126,
6143             'Literal' => 128
6144             }
6145             },
6146             {#State 420
6147             ACTIONS => {
6148             'OP05_MATH_NEG_LPAREN' => -176,
6149             'LBRACKET' => -176,
6150             'OP10_NAMED_UNARY_SCOLON' => -176,
6151             'MY' => -176,
6152             'LPAREN' => -176,
6153             'WORD_UPPERCASE' => -176,
6154             "}" => -176,
6155             'OP01_NAMED_VOID_SCOLON' => -176,
6156             "if" => -176,
6157             'OP05_LOGICAL_NEG' => -176,
6158             "foreach" => -176,
6159             'WORD' => -176,
6160             'OP05_BITWISE_NEG_LPAREN' => -176,
6161             'LITERAL_STRING' => -176,
6162             "for" => -176,
6163             'SELF' => -176,
6164             '' => -176,
6165             "while" => -176,
6166             'OP19_LOOP_CONTROL_SCOLON' => -176,
6167             "else" => 443,
6168             "\@{" => -176,
6169             'LBRACE' => -176,
6170             'OP01_CLOSE' => -176,
6171             'OP01_OPEN' => -176,
6172             'OP19_LOOP_CONTROL' => -176,
6173             "elsif" => 439,
6174             'LITERAL_NUMBER' => -176,
6175             'OP01_NAMED' => -176,
6176             'OP01_NAMED_SCOLON' => -176,
6177             'OP01_NAMED_VOID_LPAREN' => -176,
6178             'OP22_LOGICAL_NEG' => -176,
6179             'OP03_MATH_INC_DEC' => -176,
6180             'CONSTANT_CALL_SCOPED' => -176,
6181             "%{" => -176,
6182             'VARIABLE_SYMBOL' => -176,
6183             "undef" => -176,
6184             'OP01_PRINT' => -176,
6185             'OP01_NAMED_VOID' => -176,
6186             'WORD_SCOPED' => -176,
6187             'OP22_LOGICAL_NEG_LPAREN' => -176,
6188             'OP10_NAMED_UNARY' => -176
6189             },
6190             GOTOS => {
6191             'PAREN-47' => 441,
6192             'PAREN-45' => 442,
6193             'OPTIONAL-48' => 440
6194             }
6195             },
6196             {#State 421
6197             ACTIONS => {
6198             'MY' => 444
6199             },
6200             GOTOS => {
6201             'TypeInnerProperties' => 445
6202             }
6203             },
6204             {#State 422
6205             DEFAULT => -77
6206             },
6207             {#State 423
6208             ACTIONS => {
6209             "}" => 448,
6210             'OP21_LIST_COMMA' => 446
6211             },
6212             GOTOS => {
6213             'PAREN-31' => 447
6214             }
6215             },
6216             {#State 424
6217             ACTIONS => {
6218             'LBRACE' => 449
6219             }
6220             },
6221             {#State 425
6222             DEFAULT => -53
6223             },
6224             {#State 426
6225             DEFAULT => -56,
6226             GOTOS => {
6227             'STAR-23' => 450
6228             }
6229             },
6230             {#State 427
6231             ACTIONS => {
6232             'TYPE_INTEGER' => 149,
6233             'WORD_SCOPED' => 150,
6234             'WORD' => 152
6235             },
6236             GOTOS => {
6237             'Type' => 451
6238             }
6239             },
6240             {#State 428
6241             ACTIONS => {
6242             'VARIABLE_SYMBOL' => 103,
6243             "undef" => 104,
6244             'OP10_NAMED_UNARY' => 109,
6245             'WORD_SCOPED' => 25,
6246             'OP22_LOGICAL_NEG_LPAREN' => 106,
6247             'OP22_LOGICAL_NEG' => 110,
6248             'SELF' => 143,
6249             'OP03_MATH_INC_DEC' => 115,
6250             'CONSTANT_CALL_SCOPED' => 116,
6251             "%{" => 114,
6252             'OP05_LOGICAL_NEG' => 120,
6253             'OP01_OPEN' => 92,
6254             'OP01_CLOSE' => 93,
6255             'LITERAL_NUMBER' => 98,
6256             'LITERAL_STRING' => 123,
6257             'OP01_NAMED' => 165,
6258             'OP05_BITWISE_NEG_LPAREN' => 122,
6259             'WORD' => 24,
6260             "\@{" => 99,
6261             'WORD_UPPERCASE' => 161,
6262             'LPAREN' => 130,
6263             'LBRACKET' => 125,
6264             'OP05_MATH_NEG_LPAREN' => 124,
6265             'LBRACE' => 100
6266             },
6267             GOTOS => {
6268             'SubExpression' => 452,
6269             'VariableSymbolOrSelf' => 108,
6270             'HashDereference' => 142,
6271             'ArrayDereference' => 139,
6272             'WordScoped' => 140,
6273             'ArrayReference' => 134,
6274             'Expression' => 159,
6275             'Variable' => 164,
6276             'HashReference' => 126,
6277             'Operator' => 111,
6278             'Literal' => 128
6279             }
6280             },
6281             {#State 429
6282             ACTIONS => {
6283             ")" => 453
6284             }
6285             },
6286             {#State 430
6287             ACTIONS => {
6288             'VARIABLE_SYMBOL' => 454
6289             }
6290             },
6291             {#State 431
6292             ACTIONS => {
6293             ";" => 455,
6294             'OP09_BITWISE_SHIFT' => 250,
6295             'OP07_MATH_MULT_DIV_MOD' => 240,
6296             'OP11_COMPARE_LT_GT' => 249,
6297             'OP12_COMPARE_EQ_NE' => 239,
6298             'OP14_BITWISE_OR_XOR' => 237,
6299             'OP15_LOGICAL_AND' => 248,
6300             'OP07_STRING_REPEAT' => 238,
6301             'OP24_LOGICAL_OR_XOR' => 242,
6302             'OP17_LIST_RANGE' => 241,
6303             'OP16_LOGICAL_OR' => 253,
6304             'OP18_TERNARY' => 252,
6305             'OP06_REGEX_BIND' => 251,
6306             'OP13_BITWISE_AND' => 243,
6307             'OP04_MATH_POW' => 247,
6308             'OP23_LOGICAL_AND' => 246,
6309             'OP08_MATH_ADD_SUB' => 244,
6310             'OP08_STRING_CAT' => 245
6311             }
6312             },
6313             {#State 432
6314             DEFAULT => -251
6315             },
6316             {#State 433
6317             DEFAULT => -250
6318             },
6319             {#State 434
6320             ACTIONS => {
6321             'OP08_STRING_CAT' => 245,
6322             'OP08_MATH_ADD_SUB' => 244,
6323             'OP23_LOGICAL_AND' => 246,
6324             'OP04_MATH_POW' => 247,
6325             'OP13_BITWISE_AND' => 243,
6326             'OP06_REGEX_BIND' => 251,
6327             'OP18_TERNARY' => 252,
6328             'OP16_LOGICAL_OR' => 253,
6329             'OP17_LIST_RANGE' => 456,
6330             'OP24_LOGICAL_OR_XOR' => 242,
6331             'OP14_BITWISE_OR_XOR' => 237,
6332             'OP07_STRING_REPEAT' => 238,
6333             'OP15_LOGICAL_AND' => 248,
6334             'OP12_COMPARE_EQ_NE' => 239,
6335             'OP07_MATH_MULT_DIV_MOD' => 240,
6336             'OP09_BITWISE_SHIFT' => 250,
6337             'OP11_COMPARE_LT_GT' => 249
6338             }
6339             },
6340             {#State 435
6341             ACTIONS => {
6342             ")" => 457
6343             }
6344             },
6345             {#State 436
6346             ACTIONS => {
6347             "undef" => 458
6348             }
6349             },
6350             {#State 437
6351             DEFAULT => -188
6352             },
6353             {#State 438
6354             DEFAULT => -186
6355             },
6356             {#State 439
6357             ACTIONS => {
6358             'LPAREN' => 459
6359             }
6360             },
6361             {#State 440
6362             DEFAULT => -177
6363             },
6364             {#State 441
6365             DEFAULT => -175
6366             },
6367             {#State 442
6368             DEFAULT => -172
6369             },
6370             {#State 443
6371             ACTIONS => {
6372             'LBRACE' => 398
6373             },
6374             GOTOS => {
6375             'CodeBlock' => 460
6376             }
6377             },
6378             {#State 444
6379             ACTIONS => {
6380             'TYPE_INTEGER' => 149,
6381             'WORD' => 152,
6382             'WORD_SCOPED' => 150
6383             },
6384             GOTOS => {
6385             'Type' => 461
6386             }
6387             },
6388             {#State 445
6389             DEFAULT => -221
6390             },
6391             {#State 446
6392             ACTIONS => {
6393             'OP24_LOGICAL_OR_XOR' => 177,
6394             'OP01_OPEN' => 184,
6395             'OP07_STRING_REPEAT' => 171,
6396             'OP01_CLOSE' => 185,
6397             'OP11_COMPARE_LT_GT' => 188,
6398             'OP01_NAMED' => 189,
6399             'OP07_MATH_MULT_DIV_MOD' => 174,
6400             'WORD' => 173,
6401             'OP19_LOOP_CONTROL' => 187,
6402             'OP12_COMPARE_EQ_NE' => 172,
6403             'OP22_LOGICAL_NEG' => 195,
6404             'OP08_MATH_ADD_SUB' => 180,
6405             'OP23_LOGICAL_AND' => 181,
6406             'OP01_PRINT' => 191,
6407             'OP19_LOOP_CONTROL_SCOLON' => 178,
6408             'OP10_NAMED_UNARY' => 193,
6409             'OP01_NAMED_VOID' => 192
6410             },
6411             GOTOS => {
6412             'OpStringOrWord' => 402,
6413             'HashEntryProperties' => 462
6414             }
6415             },
6416             {#State 447
6417             DEFAULT => -74
6418             },
6419             {#State 448
6420             ACTIONS => {
6421             ";" => 463
6422             }
6423             },
6424             {#State 449
6425             ACTIONS => {
6426             'MY' => 464
6427             }
6428             },
6429             {#State 450
6430             ACTIONS => {
6431             'OP05_LOGICAL_NEG' => 120,
6432             'OP05_BITWISE_NEG_LPAREN' => 122,
6433             'LITERAL_STRING' => 123,
6434             "foreach" => -165,
6435             'WORD' => 24,
6436             'OP10_NAMED_UNARY_SCOLON' => 131,
6437             'MY' => 132,
6438             'LPAREN' => 130,
6439             "}" => 465,
6440             'WORD_UPPERCASE' => 129,
6441             'OP05_MATH_NEG_LPAREN' => 124,
6442             'LBRACKET' => 125,
6443             "if" => 136,
6444             'OP01_NAMED_VOID_SCOLON' => 133,
6445             'OP19_LOOP_CONTROL_SCOLON' => 138,
6446             "for" => -165,
6447             'SELF' => 143,
6448             "while" => -165,
6449             'OP01_OPEN' => 92,
6450             'OP01_CLOSE' => 93,
6451             'LITERAL_NUMBER' => 98,
6452             'OP01_NAMED' => 97,
6453             'OP19_LOOP_CONTROL' => 96,
6454             "\@{" => 99,
6455             'LBRACE' => 100,
6456             'OP01_PRINT' => 102,
6457             'VARIABLE_SYMBOL' => 103,
6458             "undef" => 104,
6459             'OP10_NAMED_UNARY' => 109,
6460             'OP01_NAMED_VOID' => 107,
6461             'WORD_SCOPED' => 25,
6462             'OP22_LOGICAL_NEG_LPAREN' => 106,
6463             'OP01_NAMED_VOID_LPAREN' => 112,
6464             'OP01_NAMED_SCOLON' => 113,
6465             'OP22_LOGICAL_NEG' => 110,
6466             'CONSTANT_CALL_SCOPED' => 116,
6467             'OP03_MATH_INC_DEC' => 115,
6468             "%{" => 114
6469             },
6470             GOTOS => {
6471             'Statement' => 137,
6472             'WordScoped' => 140,
6473             'ArrayDereference' => 139,
6474             'VariableSymbolOrSelf' => 108,
6475             'HashDereference' => 142,
6476             'SubExpression' => 141,
6477             'Operator' => 111,
6478             'LoopLabel' => 144,
6479             'Operation' => 466,
6480             'Variable' => 145,
6481             'OperatorVoid' => 95,
6482             'VariableDeclaration' => 94,
6483             'Conditional' => 118,
6484             'PAREN-43' => 119,
6485             'VariableModification' => 121,
6486             'HashReference' => 126,
6487             'Literal' => 128,
6488             'Expression' => 135,
6489             'ArrayReference' => 134,
6490             'OPTIONAL-44' => 101
6491             }
6492             },
6493             {#State 451
6494             ACTIONS => {
6495             'VARIABLE_SYMBOL' => 467
6496             }
6497             },
6498             {#State 452
6499             ACTIONS => {
6500             'OP07_STRING_REPEAT' => 238,
6501             'OP14_BITWISE_OR_XOR' => 237,
6502             'OP15_LOGICAL_AND' => 248,
6503             'OP12_COMPARE_EQ_NE' => 239,
6504             'OP21_LIST_COMMA' => -96,
6505             ";" => -96,
6506             'OP07_MATH_MULT_DIV_MOD' => 240,
6507             'OP09_BITWISE_SHIFT' => 250,
6508             'OP11_COMPARE_LT_GT' => 249,
6509             'OP17_LIST_RANGE' => 241,
6510             "}" => -96,
6511             'OP24_LOGICAL_OR_XOR' => -96,
6512             'OP06_REGEX_BIND' => 251,
6513             'OP13_BITWISE_AND' => 243,
6514             'OP18_TERNARY' => 252,
6515             ")" => -96,
6516             'OP16_LOGICAL_OR' => 253,
6517             'OP08_MATH_ADD_SUB' => 244,
6518             'OP08_STRING_CAT' => 245,
6519             "]" => -96,
6520             'OP23_LOGICAL_AND' => -96,
6521             'OP04_MATH_POW' => 247
6522             }
6523             },
6524             {#State 453
6525             ACTIONS => {
6526             'LBRACE' => 398
6527             },
6528             GOTOS => {
6529             'CodeBlock' => 468
6530             }
6531             },
6532             {#State 454
6533             ACTIONS => {
6534             'OP11_COMPARE_LT_GT' => 469
6535             }
6536             },
6537             {#State 455
6538             DEFAULT => -252
6539             },
6540             {#State 456
6541             ACTIONS => {
6542             'WORD' => 24,
6543             'LITERAL_NUMBER' => 98,
6544             'OP05_BITWISE_NEG_LPAREN' => 122,
6545             'LITERAL_STRING' => 123,
6546             'OP01_NAMED' => 165,
6547             'OP01_OPEN' => 92,
6548             'OP05_LOGICAL_NEG' => 120,
6549             'OP01_CLOSE' => 93,
6550             'LBRACE' => 100,
6551             'OP05_MATH_NEG_LPAREN' => 124,
6552             'LBRACKET' => 125,
6553             "\@{" => 99,
6554             'LPAREN' => 130,
6555             'WORD_UPPERCASE' => 161,
6556             'WORD_SCOPED' => 25,
6557             'OP22_LOGICAL_NEG_LPAREN' => 106,
6558             'OP10_NAMED_UNARY' => 109,
6559             'VARIABLE_SYMBOL' => 103,
6560             "undef" => 104,
6561             'CONSTANT_CALL_SCOPED' => 116,
6562             "%{" => 114,
6563             'OP03_MATH_INC_DEC' => 115,
6564             'SELF' => 143,
6565             'OP22_LOGICAL_NEG' => 110
6566             },
6567             GOTOS => {
6568             'Operator' => 111,
6569             'Literal' => 128,
6570             'HashReference' => 126,
6571             'Variable' => 164,
6572             'Expression' => 159,
6573             'ArrayReference' => 134,
6574             'WordScoped' => 140,
6575             'ArrayDereference' => 139,
6576             'SubExpression' => 470,
6577             'HashDereference' => 142,
6578             'VariableSymbolOrSelf' => 108
6579             }
6580             },
6581             {#State 457
6582             ACTIONS => {
6583             'LBRACE' => 398
6584             },
6585             GOTOS => {
6586             'CodeBlock' => 471
6587             }
6588             },
6589             {#State 458
6590             ACTIONS => {
6591             ";" => 472
6592             }
6593             },
6594             {#State 459
6595             ACTIONS => {
6596             'OP10_NAMED_UNARY' => 109,
6597             'OP22_LOGICAL_NEG_LPAREN' => 106,
6598             'WORD_SCOPED' => 25,
6599             'VARIABLE_SYMBOL' => 103,
6600             "undef" => 104,
6601             'CONSTANT_CALL_SCOPED' => 116,
6602             "%{" => 114,
6603             'OP03_MATH_INC_DEC' => 115,
6604             'OP22_LOGICAL_NEG' => 110,
6605             'SELF' => 143,
6606             'OP01_NAMED' => 165,
6607             'LITERAL_STRING' => 123,
6608             'OP05_BITWISE_NEG_LPAREN' => 122,
6609             'LITERAL_NUMBER' => 98,
6610             'WORD' => 24,
6611             'OP05_LOGICAL_NEG' => 120,
6612             'OP01_OPEN' => 92,
6613             'OP01_CLOSE' => 93,
6614             'LBRACE' => 100,
6615             "\@{" => 99,
6616             'LPAREN' => 130,
6617             'WORD_UPPERCASE' => 161,
6618             'LBRACKET' => 125,
6619             'OP05_MATH_NEG_LPAREN' => 124
6620             },
6621             GOTOS => {
6622             'HashReference' => 126,
6623             'Operator' => 111,
6624             'Literal' => 128,
6625             'Expression' => 159,
6626             'ArrayReference' => 134,
6627             'Variable' => 164,
6628             'ArrayDereference' => 139,
6629             'WordScoped' => 140,
6630             'HashDereference' => 142,
6631             'VariableSymbolOrSelf' => 108,
6632             'SubExpression' => 473
6633             }
6634             },
6635             {#State 460
6636             DEFAULT => -174
6637             },
6638             {#State 461
6639             ACTIONS => {
6640             "\$TYPED_" => 474
6641             }
6642             },
6643             {#State 462
6644             DEFAULT => -73
6645             },
6646             {#State 463
6647             DEFAULT => -76
6648             },
6649             {#State 464
6650             ACTIONS => {
6651             'WORD' => 152,
6652             'WORD_SCOPED' => 150,
6653             'TYPE_METHOD' => 475,
6654             'TYPE_INTEGER' => 149
6655             },
6656             GOTOS => {
6657             'Type' => 264
6658             }
6659             },
6660             {#State 465
6661             DEFAULT => -57
6662             },
6663             {#State 466
6664             DEFAULT => -55
6665             },
6666             {#State 467
6667             DEFAULT => -60,
6668             GOTOS => {
6669             'STAR-25' => 476
6670             }
6671             },
6672             {#State 468
6673             DEFAULT => -185
6674             },
6675             {#State 469
6676             ACTIONS => {
6677             'OP01_NAMED_SCOLON' => 433,
6678             'OP22_LOGICAL_NEG' => 110,
6679             'SELF' => 143,
6680             'OP03_MATH_INC_DEC' => 115,
6681             'CONSTANT_CALL_SCOPED' => 116,
6682             "%{" => 114,
6683             'VARIABLE_SYMBOL' => 103,
6684             "undef" => 104,
6685             'OP10_NAMED_UNARY' => 109,
6686             'WORD_SCOPED' => 25,
6687             'OP22_LOGICAL_NEG_LPAREN' => 106,
6688             'OP10_NAMED_UNARY_SCOLON' => 432,
6689             "\@{" => 99,
6690             'LPAREN' => 130,
6691             'WORD_UPPERCASE' => 161,
6692             'LBRACKET' => 125,
6693             'OP05_MATH_NEG_LPAREN' => 124,
6694             'LBRACE' => 100,
6695             'OP05_LOGICAL_NEG' => 120,
6696             'OP01_OPEN' => 92,
6697             'OP01_CLOSE' => 93,
6698             'LITERAL_NUMBER' => 98,
6699             'LITERAL_STRING' => 123,
6700             'OP01_NAMED' => 165,
6701             'OP05_BITWISE_NEG_LPAREN' => 122,
6702             'WORD' => 24
6703             },
6704             GOTOS => {
6705             'OpNamedScolonOrSubExp' => 477,
6706             'SubExpression' => 431,
6707             'HashDereference' => 142,
6708             'VariableSymbolOrSelf' => 108,
6709             'WordScoped' => 140,
6710             'ArrayDereference' => 139,
6711             'Variable' => 164,
6712             'Expression' => 159,
6713             'ArrayReference' => 134,
6714             'Literal' => 128,
6715             'Operator' => 111,
6716             'HashReference' => 126
6717             }
6718             },
6719             {#State 470
6720             ACTIONS => {
6721             'OP08_STRING_CAT' => 245,
6722             'OP08_MATH_ADD_SUB' => 244,
6723             'OP23_LOGICAL_AND' => -118,
6724             'OP04_MATH_POW' => 247,
6725             'OP13_BITWISE_AND' => 243,
6726             'OP06_REGEX_BIND' => 251,
6727             'OP18_TERNARY' => -118,
6728             ")" => 478,
6729             'OP16_LOGICAL_OR' => 253,
6730             'OP17_LIST_RANGE' => undef,
6731             'OP24_LOGICAL_OR_XOR' => -118,
6732             'OP15_LOGICAL_AND' => 248,
6733             'OP07_STRING_REPEAT' => 238,
6734             'OP14_BITWISE_OR_XOR' => 237,
6735             'OP12_COMPARE_EQ_NE' => 239,
6736             'OP07_MATH_MULT_DIV_MOD' => 240,
6737             'OP09_BITWISE_SHIFT' => 250,
6738             'OP11_COMPARE_LT_GT' => 249
6739             }
6740             },
6741             {#State 471
6742             DEFAULT => -183
6743             },
6744             {#State 472
6745             DEFAULT => -197
6746             },
6747             {#State 473
6748             ACTIONS => {
6749             'OP24_LOGICAL_OR_XOR' => 242,
6750             'OP17_LIST_RANGE' => 241,
6751             'OP12_COMPARE_EQ_NE' => 239,
6752             'OP09_BITWISE_SHIFT' => 250,
6753             'OP07_MATH_MULT_DIV_MOD' => 240,
6754             'OP11_COMPARE_LT_GT' => 249,
6755             'OP15_LOGICAL_AND' => 248,
6756             'OP14_BITWISE_OR_XOR' => 237,
6757             'OP07_STRING_REPEAT' => 238,
6758             'OP23_LOGICAL_AND' => 246,
6759             'OP04_MATH_POW' => 247,
6760             'OP08_STRING_CAT' => 245,
6761             'OP08_MATH_ADD_SUB' => 244,
6762             ")" => 479,
6763             'OP16_LOGICAL_OR' => 253,
6764             'OP06_REGEX_BIND' => 251,
6765             'OP13_BITWISE_AND' => 243,
6766             'OP18_TERNARY' => 252
6767             }
6768             },
6769             {#State 474
6770             ACTIONS => {
6771             'OP24_LOGICAL_OR_XOR' => 177,
6772             'OP01_OPEN' => 184,
6773             'OP01_CLOSE' => 185,
6774             'OP07_STRING_REPEAT' => 171,
6775             'WORD' => 173,
6776             'OP19_LOOP_CONTROL' => 187,
6777             'OP12_COMPARE_EQ_NE' => 172,
6778             'OP11_COMPARE_LT_GT' => 188,
6779             'OP07_MATH_MULT_DIV_MOD' => 174,
6780             'OP01_NAMED' => 189,
6781             'OP22_LOGICAL_NEG' => 195,
6782             'OP08_MATH_ADD_SUB' => 180,
6783             'OP23_LOGICAL_AND' => 181,
6784             'OP01_PRINT' => 191,
6785             'OP19_LOOP_CONTROL_SCOLON' => 178,
6786             'OP01_NAMED_VOID' => 192,
6787             'OP10_NAMED_UNARY' => 193
6788             },
6789             GOTOS => {
6790             'OpStringOrWord' => 480
6791             }
6792             },
6793             {#State 475
6794             ACTIONS => {
6795             "\$RETURN_TYPE" => 481
6796             }
6797             },
6798             {#State 476
6799             ACTIONS => {
6800             'OP21_LIST_COMMA' => 482,
6801             ")" => 484
6802             },
6803             GOTOS => {
6804             'PAREN-24' => 483
6805             }
6806             },
6807             {#State 477
6808             ACTIONS => {
6809             'OP22_LOGICAL_NEG' => 110,
6810             'SELF' => 143,
6811             "%{" => 114,
6812             'CONSTANT_CALL_SCOPED' => 116,
6813             'OP03_MATH_INC_DEC' => 115,
6814             "undef" => 104,
6815             'VARIABLE_SYMBOL' => 103,
6816             'OP10_NAMED_UNARY' => 109,
6817             'OP22_LOGICAL_NEG_LPAREN' => 106,
6818             'WORD_SCOPED' => 25,
6819             'WORD_UPPERCASE' => 161,
6820             "\@{" => 99,
6821             'LPAREN' => 130,
6822             'OP05_MATH_NEG_LPAREN' => 124,
6823             'LBRACKET' => 125,
6824             'LBRACE' => 100,
6825             'OP01_CLOSE' => 93,
6826             'OP05_LOGICAL_NEG' => 120,
6827             'OP01_OPEN' => 92,
6828             'LITERAL_STRING' => 123,
6829             'OP01_NAMED' => 165,
6830             'OP05_BITWISE_NEG_LPAREN' => 122,
6831             'LITERAL_NUMBER' => 98,
6832             'WORD' => 24
6833             },
6834             GOTOS => {
6835             'Variable' => 145,
6836             'ArrayReference' => 134,
6837             'Expression' => 159,
6838             'SubExpressionOrVarMod' => 487,
6839             'Literal' => 128,
6840             'Operator' => 111,
6841             'HashReference' => 126,
6842             'HashDereference' => 142,
6843             'VariableSymbolOrSelf' => 108,
6844             'SubExpression' => 485,
6845             'VariableModification' => 486,
6846             'ArrayDereference' => 139,
6847             'WordScoped' => 140
6848             }
6849             },
6850             {#State 478
6851             ACTIONS => {
6852             'LBRACE' => 398
6853             },
6854             GOTOS => {
6855             'CodeBlock' => 488
6856             }
6857             },
6858             {#State 479
6859             ACTIONS => {
6860             'LBRACE' => 398
6861             },
6862             GOTOS => {
6863             'CodeBlock' => 489
6864             }
6865             },
6866             {#State 480
6867             ACTIONS => {
6868             'OP02_ARRAY_THINARROW' => 490,
6869             'OP19_VARIABLE_ASSIGN' => 491
6870             }
6871             },
6872             {#State 481
6873             ACTIONS => {
6874             "}" => 492
6875             }
6876             },
6877             {#State 482
6878             ACTIONS => {
6879             'MY' => 493
6880             }
6881             },
6882             {#State 483
6883             DEFAULT => -59
6884             },
6885             {#State 484
6886             ACTIONS => {
6887             'OP19_VARIABLE_ASSIGN' => 494
6888             }
6889             },
6890             {#State 485
6891             ACTIONS => {
6892             ")" => -161,
6893             'OP16_LOGICAL_OR' => 253,
6894             'OP13_BITWISE_AND' => 243,
6895             'OP06_REGEX_BIND' => 251,
6896             'OP18_TERNARY' => 252,
6897             'OP23_LOGICAL_AND' => 246,
6898             'OP04_MATH_POW' => 247,
6899             'OP08_MATH_ADD_SUB' => 244,
6900             'OP08_STRING_CAT' => 245,
6901             'OP12_COMPARE_EQ_NE' => 239,
6902             'OP07_MATH_MULT_DIV_MOD' => 240,
6903             'OP11_COMPARE_LT_GT' => 249,
6904             'OP09_BITWISE_SHIFT' => 250,
6905             'OP15_LOGICAL_AND' => 248,
6906             'OP07_STRING_REPEAT' => 238,
6907             'OP14_BITWISE_OR_XOR' => 237,
6908             'OP24_LOGICAL_OR_XOR' => 242,
6909             'OP17_LIST_RANGE' => 241
6910             }
6911             },
6912             {#State 486
6913             DEFAULT => -162
6914             },
6915             {#State 487
6916             ACTIONS => {
6917             ")" => 495
6918             }
6919             },
6920             {#State 488
6921             DEFAULT => -181
6922             },
6923             {#State 489
6924             DEFAULT => -171
6925             },
6926             {#State 490
6927             ACTIONS => {
6928             'OP01_OPEN' => 92,
6929             'OP01_CLOSE' => 93,
6930             'OP05_LOGICAL_NEG' => 120,
6931             'WORD' => 24,
6932             'LITERAL_NUMBER' => 98,
6933             'OP01_NAMED' => 165,
6934             'OP05_BITWISE_NEG_LPAREN' => 122,
6935             'LITERAL_STRING' => 123,
6936             'LBRACKET' => 125,
6937             'OP05_MATH_NEG_LPAREN' => 124,
6938             'WORD_UPPERCASE' => 161,
6939             "\@{" => 99,
6940             'LPAREN' => 130,
6941             'LBRACE' => 100,
6942             "undef" => 104,
6943             'VARIABLE_SYMBOL' => 103,
6944             'OP22_LOGICAL_NEG_LPAREN' => 106,
6945             'WORD_SCOPED' => 25,
6946             'OP10_NAMED_UNARY' => 109,
6947             'SELF' => 143,
6948             'OP22_LOGICAL_NEG' => 110,
6949             'OP03_MATH_INC_DEC' => 115,
6950             'CONSTANT_CALL_SCOPED' => 116,
6951             "%{" => 114
6952             },
6953             GOTOS => {
6954             'Variable' => 164,
6955             'ArrayReference' => 134,
6956             'Expression' => 159,
6957             'Literal' => 128,
6958             'Operator' => 111,
6959             'HashReference' => 126,
6960             'SubExpression' => 496,
6961             'HashDereference' => 142,
6962             'VariableSymbolOrSelf' => 108,
6963             'ArrayDereference' => 139,
6964             'WordScoped' => 140
6965             }
6966             },
6967             {#State 491
6968             ACTIONS => {
6969             'VARIABLE_SYMBOL' => 103,
6970             "undef" => 104,
6971             'OP22_LOGICAL_NEG_LPAREN' => 106,
6972             'WORD_SCOPED' => 25,
6973             'OP10_NAMED_UNARY' => 109,
6974             'SELF' => 143,
6975             'OP22_LOGICAL_NEG' => 110,
6976             'OP03_MATH_INC_DEC' => 115,
6977             'CONSTANT_CALL_SCOPED' => 116,
6978             "%{" => 114,
6979             'OP01_OPEN' => 92,
6980             'OP05_LOGICAL_NEG' => 120,
6981             'OP01_CLOSE' => 93,
6982             'WORD' => 24,
6983             'LITERAL_NUMBER' => 98,
6984             'LITERAL_STRING' => 123,
6985             'OP05_BITWISE_NEG_LPAREN' => 122,
6986             'OP01_NAMED' => 165,
6987             'OP05_MATH_NEG_LPAREN' => 124,
6988             'LBRACKET' => 125,
6989             'WORD_UPPERCASE' => 161,
6990             'LPAREN' => 130,
6991             "\@{" => 99,
6992             'LBRACE' => 100
6993             },
6994             GOTOS => {
6995             'Variable' => 164,
6996             'ArrayReference' => 134,
6997             'Expression' => 159,
6998             'Literal' => 128,
6999             'Operator' => 111,
7000             'HashReference' => 126,
7001             'HashDereference' => 142,
7002             'VariableSymbolOrSelf' => 108,
7003             'SubExpression' => 497,
7004             'ArrayDereference' => 139,
7005             'WordScoped' => 140
7006             }
7007             },
7008             {#State 492
7009             ACTIONS => {
7010             ";" => 498
7011             }
7012             },
7013             {#State 493
7014             ACTIONS => {
7015             'TYPE_INTEGER' => 149,
7016             'WORD' => 152,
7017             'WORD_SCOPED' => 150
7018             },
7019             GOTOS => {
7020             'Type' => 499
7021             }
7022             },
7023             {#State 494
7024             ACTIONS => {
7025             "\@ARG;" => 500
7026             }
7027             },
7028             {#State 495
7029             ACTIONS => {
7030             'LBRACE' => 398
7031             },
7032             GOTOS => {
7033             'CodeBlock' => 501
7034             }
7035             },
7036             {#State 496
7037             ACTIONS => {
7038             'OP17_LIST_RANGE' => 241,
7039             'OP24_LOGICAL_OR_XOR' => 242,
7040             'OP07_STRING_REPEAT' => 238,
7041             'OP14_BITWISE_OR_XOR' => 237,
7042             'OP15_LOGICAL_AND' => 248,
7043             'OP11_COMPARE_LT_GT' => 249,
7044             'OP07_MATH_MULT_DIV_MOD' => 240,
7045             'OP09_BITWISE_SHIFT' => 250,
7046             'OP12_COMPARE_EQ_NE' => 239,
7047             'OP08_STRING_CAT' => 245,
7048             "]" => 502,
7049             'OP08_MATH_ADD_SUB' => 244,
7050             'OP04_MATH_POW' => 247,
7051             'OP23_LOGICAL_AND' => 246,
7052             'OP18_TERNARY' => 252,
7053             'OP13_BITWISE_AND' => 243,
7054             'OP06_REGEX_BIND' => 251,
7055             'OP16_LOGICAL_OR' => 253
7056             }
7057             },
7058             {#State 497
7059             ACTIONS => {
7060             'OP08_STRING_CAT' => 245,
7061             'OP08_MATH_ADD_SUB' => 244,
7062             'OP23_LOGICAL_AND' => 246,
7063             'OP04_MATH_POW' => 247,
7064             'OP13_BITWISE_AND' => 243,
7065             'OP06_REGEX_BIND' => 251,
7066             'OP18_TERNARY' => 252,
7067             'OP16_LOGICAL_OR' => 253,
7068             'OP17_LIST_RANGE' => 241,
7069             "}" => -238,
7070             'OP24_LOGICAL_OR_XOR' => 242,
7071             'OP07_STRING_REPEAT' => 238,
7072             'OP14_BITWISE_OR_XOR' => 237,
7073             'OP15_LOGICAL_AND' => 248,
7074             'OP21_LIST_COMMA' => -238,
7075             'OP12_COMPARE_EQ_NE' => 239,
7076             'OP09_BITWISE_SHIFT' => 250,
7077             'OP07_MATH_MULT_DIV_MOD' => 240,
7078             'OP11_COMPARE_LT_GT' => 249
7079             }
7080             },
7081             {#State 498
7082             ACTIONS => {
7083             'OP19_LOOP_CONTROL_SCOLON' => -79,
7084             "for" => -79,
7085             'SELF' => -79,
7086             "while" => -79,
7087             'OP05_LOGICAL_NEG' => -79,
7088             'OP05_BITWISE_NEG_LPAREN' => -79,
7089             'LITERAL_STRING' => -79,
7090             "foreach" => -79,
7091             'WORD' => -79,
7092             'MY' => -79,
7093             'OP10_NAMED_UNARY_SCOLON' => -79,
7094             'WORD_UPPERCASE' => -79,
7095             'LPAREN' => -79,
7096             "}" => -79,
7097             'LBRACKET' => -79,
7098             'OP05_MATH_NEG_LPAREN' => -79,
7099             "if" => -79,
7100             'OP01_NAMED_VOID_SCOLON' => -79,
7101             'VARIABLE_SYMBOL' => -79,
7102             'OP01_PRINT' => -79,
7103             "undef" => -79,
7104             'OP10_NAMED_UNARY' => -79,
7105             'OP22_LOGICAL_NEG_LPAREN' => -79,
7106             'OP01_NAMED_VOID' => -79,
7107             'WORD_SCOPED' => -79,
7108             'OP01_NAMED_SCOLON' => -79,
7109             'OP01_NAMED_VOID_LPAREN' => -79,
7110             'OP22_LOGICAL_NEG' => -79,
7111             'OP03_MATH_INC_DEC' => -79,
7112             "%{" => -79,
7113             'CONSTANT_CALL_SCOPED' => -79,
7114             'LPAREN_MY' => 503,
7115             'OP01_OPEN' => -79,
7116             'OP01_CLOSE' => -79,
7117             'LITERAL_NUMBER' => -79,
7118             'OP01_NAMED' => -79,
7119             'OP19_LOOP_CONTROL' => -79,
7120             "\@{" => -79,
7121             'LBRACE' => -79
7122             },
7123             GOTOS => {
7124             'MethodArguments' => 504,
7125             'OPTIONAL-33' => 505
7126             }
7127             },
7128             {#State 499
7129             ACTIONS => {
7130             'VARIABLE_SYMBOL' => 506
7131             }
7132             },
7133             {#State 500
7134             DEFAULT => -61
7135             },
7136             {#State 501
7137             DEFAULT => -182
7138             },
7139             {#State 502
7140             ACTIONS => {
7141             'OP19_VARIABLE_ASSIGN' => 507
7142             }
7143             },
7144             {#State 503
7145             ACTIONS => {
7146             'TYPE_INTEGER' => 149,
7147             'WORD_SCOPED' => 150,
7148             'WORD' => 152
7149             },
7150             GOTOS => {
7151             'Type' => 508
7152             }
7153             },
7154             {#State 504
7155             DEFAULT => -78
7156             },
7157             {#State 505
7158             DEFAULT => -81,
7159             GOTOS => {
7160             'STAR-34' => 509
7161             }
7162             },
7163             {#State 506
7164             DEFAULT => -58
7165             },
7166             {#State 507
7167             ACTIONS => {
7168             "undef" => 510
7169             }
7170             },
7171             {#State 508
7172             ACTIONS => {
7173             'SELF' => 511
7174             }
7175             },
7176             {#State 509
7177             ACTIONS => {
7178             'LITERAL_STRING' => 123,
7179             'OP05_BITWISE_NEG_LPAREN' => 122,
7180             'WORD' => 24,
7181             "foreach" => -165,
7182             'OP05_LOGICAL_NEG' => 120,
7183             "if" => 136,
7184             'OP01_NAMED_VOID_SCOLON' => 133,
7185             'LPAREN' => 130,
7186             "}" => 513,
7187             'WORD_UPPERCASE' => 129,
7188             'OP10_NAMED_UNARY_SCOLON' => 131,
7189             'MY' => 132,
7190             'OP05_MATH_NEG_LPAREN' => 124,
7191             'LBRACKET' => 125,
7192             'OP19_LOOP_CONTROL_SCOLON' => 138,
7193             "while" => -165,
7194             'SELF' => 143,
7195             "for" => -165,
7196             'OP01_NAMED' => 97,
7197             'LITERAL_NUMBER' => 98,
7198             'OP19_LOOP_CONTROL' => 96,
7199             'OP01_CLOSE' => 93,
7200             'OP01_OPEN' => 92,
7201             'LBRACE' => 100,
7202             "\@{" => 99,
7203             'OP10_NAMED_UNARY' => 109,
7204             'WORD_SCOPED' => 25,
7205             'OP01_NAMED_VOID' => 107,
7206             'OP22_LOGICAL_NEG_LPAREN' => 106,
7207             'OP01_PRINT' => 102,
7208             'VARIABLE_SYMBOL' => 103,
7209             "undef" => 104,
7210             "%{" => 114,
7211             'OP03_MATH_INC_DEC' => 115,
7212             'CONSTANT_CALL_SCOPED' => 116,
7213             'OP22_LOGICAL_NEG' => 110,
7214             'OP01_NAMED_SCOLON' => 113,
7215             'OP01_NAMED_VOID_LPAREN' => 112
7216             },
7217             GOTOS => {
7218             'HashReference' => 126,
7219             'Literal' => 128,
7220             'ArrayReference' => 134,
7221             'Expression' => 135,
7222             'OPTIONAL-44' => 101,
7223             'OperatorVoid' => 95,
7224             'VariableDeclaration' => 94,
7225             'Conditional' => 118,
7226             'PAREN-43' => 119,
7227             'VariableModification' => 121,
7228             'Operator' => 111,
7229             'LoopLabel' => 144,
7230             'Variable' => 145,
7231             'Operation' => 512,
7232             'Statement' => 137,
7233             'ArrayDereference' => 139,
7234             'WordScoped' => 140,
7235             'VariableSymbolOrSelf' => 108,
7236             'HashDereference' => 142,
7237             'SubExpression' => 141
7238             }
7239             },
7240             {#State 510
7241             DEFAULT => -239
7242             },
7243             {#State 511
7244             DEFAULT => -85,
7245             GOTOS => {
7246             'STAR-36' => 514
7247             }
7248             },
7249             {#State 512
7250             DEFAULT => -80
7251             },
7252             {#State 513
7253             DEFAULT => -82
7254             },
7255             {#State 514
7256             ACTIONS => {
7257             'OP21_LIST_COMMA' => 516,
7258             ")" => 517
7259             },
7260             GOTOS => {
7261             'PAREN-35' => 515
7262             }
7263             },
7264             {#State 515
7265             DEFAULT => -84
7266             },
7267             {#State 516
7268             ACTIONS => {
7269             'MY' => 518
7270             }
7271             },
7272             {#State 517
7273             ACTIONS => {
7274             'OP19_VARIABLE_ASSIGN' => 519
7275             }
7276             },
7277             {#State 518
7278             ACTIONS => {
7279             'WORD' => 152,
7280             'WORD_SCOPED' => 150,
7281             'TYPE_INTEGER' => 149
7282             },
7283             GOTOS => {
7284             'Type' => 520
7285             }
7286             },
7287             {#State 519
7288             ACTIONS => {
7289             "\@ARG;" => 521
7290             }
7291             },
7292             {#State 520
7293             ACTIONS => {
7294             'VARIABLE_SYMBOL' => 522
7295             }
7296             },
7297             {#State 521
7298             DEFAULT => -86
7299             },
7300             {#State 522
7301             DEFAULT => -83
7302             }
7303             ],
7304             yyrules =>
7305             [
7306             [#Rule _SUPERSTART
7307             '$start', 2, undef
7308             #line 7308 lib/RPerl/Grammar.pm
7309             ],
7310             [#Rule _PAREN
7311             'PAREN-1', 2,
7312             sub {
7313             #line 188 "lib/RPerl/Grammar.eyp"
7314             goto &Parse::Eyapp::Driver::YYActionforParenthesis}
7315             #line 7315 lib/RPerl/Grammar.pm
7316             ],
7317             [#Rule _PLUS_LIST
7318             'PLUS-2', 2,
7319             sub {
7320             #line 188 "lib/RPerl/Grammar.eyp"
7321             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7322             #line 7322 lib/RPerl/Grammar.pm
7323             ],
7324             [#Rule _PLUS_LIST
7325             'PLUS-2', 1,
7326             sub {
7327             #line 188 "lib/RPerl/Grammar.eyp"
7328             goto &Parse::Eyapp::Driver::YYActionforT_single }
7329             #line 7329 lib/RPerl/Grammar.pm
7330             ],
7331             [#Rule CompileUnit_4
7332             'CompileUnit', 1,
7333             sub {
7334             #line 24 "lib/RPerl/Grammar.eyp"
7335              
7336             my $self = shift;
7337             my $name = $self->YYName();
7338             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7339             }
7340             #line 7340 lib/RPerl/Grammar.pm
7341             ],
7342             [#Rule CompileUnit_5
7343             'CompileUnit', 1,
7344             sub {
7345             #line 24 "lib/RPerl/Grammar.eyp"
7346              
7347             my $self = shift;
7348             my $name = $self->YYName();
7349             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7350             }
7351             #line 7351 lib/RPerl/Grammar.pm
7352             ],
7353             [#Rule _OPTIONAL
7354             'OPTIONAL-3', 1,
7355             sub {
7356             #line 189 "lib/RPerl/Grammar.eyp"
7357             goto &Parse::Eyapp::Driver::YYActionforT_single }
7358             #line 7358 lib/RPerl/Grammar.pm
7359             ],
7360             [#Rule _OPTIONAL
7361             'OPTIONAL-3', 0,
7362             sub {
7363             #line 189 "lib/RPerl/Grammar.eyp"
7364             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7365             #line 7365 lib/RPerl/Grammar.pm
7366             ],
7367             [#Rule _STAR_LIST
7368             'STAR-4', 2,
7369             sub {
7370             #line 189 "lib/RPerl/Grammar.eyp"
7371             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7372             #line 7372 lib/RPerl/Grammar.pm
7373             ],
7374             [#Rule _STAR_LIST
7375             'STAR-4', 0,
7376             sub {
7377             #line 189 "lib/RPerl/Grammar.eyp"
7378             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7379             #line 7379 lib/RPerl/Grammar.pm
7380             ],
7381             [#Rule _STAR_LIST
7382             'STAR-5', 2,
7383             sub {
7384             #line 189 "lib/RPerl/Grammar.eyp"
7385             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7386             #line 7386 lib/RPerl/Grammar.pm
7387             ],
7388             [#Rule _STAR_LIST
7389             'STAR-5', 0,
7390             sub {
7391             #line 189 "lib/RPerl/Grammar.eyp"
7392             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7393             #line 7393 lib/RPerl/Grammar.pm
7394             ],
7395             [#Rule _STAR_LIST
7396             'STAR-6', 2,
7397             sub {
7398             #line 189 "lib/RPerl/Grammar.eyp"
7399             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7400             #line 7400 lib/RPerl/Grammar.pm
7401             ],
7402             [#Rule _STAR_LIST
7403             'STAR-6', 0,
7404             sub {
7405             #line 189 "lib/RPerl/Grammar.eyp"
7406             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7407             #line 7407 lib/RPerl/Grammar.pm
7408             ],
7409             [#Rule _STAR_LIST
7410             'STAR-7', 2,
7411             sub {
7412             #line 189 "lib/RPerl/Grammar.eyp"
7413             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7414             #line 7414 lib/RPerl/Grammar.pm
7415             ],
7416             [#Rule _STAR_LIST
7417             'STAR-7', 0,
7418             sub {
7419             #line 189 "lib/RPerl/Grammar.eyp"
7420             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7421             #line 7421 lib/RPerl/Grammar.pm
7422             ],
7423             [#Rule _PLUS_LIST
7424             'PLUS-8', 2,
7425             sub {
7426             #line 189 "lib/RPerl/Grammar.eyp"
7427             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7428             #line 7428 lib/RPerl/Grammar.pm
7429             ],
7430             [#Rule _PLUS_LIST
7431             'PLUS-8', 1,
7432             sub {
7433             #line 189 "lib/RPerl/Grammar.eyp"
7434             goto &Parse::Eyapp::Driver::YYActionforT_single }
7435             #line 7435 lib/RPerl/Grammar.pm
7436             ],
7437             [#Rule Program_18
7438             'Program', 9,
7439             sub {
7440             #line 24 "lib/RPerl/Grammar.eyp"
7441              
7442             my $self = shift;
7443             my $name = $self->YYName();
7444             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7445             }
7446             #line 7446 lib/RPerl/Grammar.pm
7447             ],
7448             [#Rule _OPTIONAL
7449             'OPTIONAL-9', 1,
7450             sub {
7451             #line 190 "lib/RPerl/Grammar.eyp"
7452             goto &Parse::Eyapp::Driver::YYActionforT_single }
7453             #line 7453 lib/RPerl/Grammar.pm
7454             ],
7455             [#Rule _OPTIONAL
7456             'OPTIONAL-9', 0,
7457             sub {
7458             #line 190 "lib/RPerl/Grammar.eyp"
7459             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7460             #line 7460 lib/RPerl/Grammar.pm
7461             ],
7462             [#Rule _OPTIONAL
7463             'OPTIONAL-10', 1,
7464             sub {
7465             #line 190 "lib/RPerl/Grammar.eyp"
7466             goto &Parse::Eyapp::Driver::YYActionforT_single }
7467             #line 7467 lib/RPerl/Grammar.pm
7468             ],
7469             [#Rule _OPTIONAL
7470             'OPTIONAL-10', 0,
7471             sub {
7472             #line 190 "lib/RPerl/Grammar.eyp"
7473             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7474             #line 7474 lib/RPerl/Grammar.pm
7475             ],
7476             [#Rule ModuleHeader_23
7477             'ModuleHeader', 6,
7478             sub {
7479             #line 24 "lib/RPerl/Grammar.eyp"
7480              
7481             my $self = shift;
7482             my $name = $self->YYName();
7483             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7484             }
7485             #line 7485 lib/RPerl/Grammar.pm
7486             ],
7487             [#Rule Module_24
7488             'Module', 1,
7489             sub {
7490             #line 24 "lib/RPerl/Grammar.eyp"
7491              
7492             my $self = shift;
7493             my $name = $self->YYName();
7494             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7495             }
7496             #line 7496 lib/RPerl/Grammar.pm
7497             ],
7498             [#Rule Module_25
7499             'Module', 1,
7500             sub {
7501             #line 24 "lib/RPerl/Grammar.eyp"
7502              
7503             my $self = shift;
7504             my $name = $self->YYName();
7505             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7506             }
7507             #line 7507 lib/RPerl/Grammar.pm
7508             ],
7509             [#Rule _STAR_LIST
7510             'STAR-11', 2,
7511             sub {
7512             #line 192 "lib/RPerl/Grammar.eyp"
7513             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7514             #line 7514 lib/RPerl/Grammar.pm
7515             ],
7516             [#Rule _STAR_LIST
7517             'STAR-11', 0,
7518             sub {
7519             #line 192 "lib/RPerl/Grammar.eyp"
7520             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7521             #line 7521 lib/RPerl/Grammar.pm
7522             ],
7523             [#Rule _OPTIONAL
7524             'OPTIONAL-12', 1,
7525             sub {
7526             #line 192 "lib/RPerl/Grammar.eyp"
7527             goto &Parse::Eyapp::Driver::YYActionforT_single }
7528             #line 7528 lib/RPerl/Grammar.pm
7529             ],
7530             [#Rule _OPTIONAL
7531             'OPTIONAL-12', 0,
7532             sub {
7533             #line 192 "lib/RPerl/Grammar.eyp"
7534             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7535             #line 7535 lib/RPerl/Grammar.pm
7536             ],
7537             [#Rule _STAR_LIST
7538             'STAR-13', 2,
7539             sub {
7540             #line 192 "lib/RPerl/Grammar.eyp"
7541             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7542             #line 7542 lib/RPerl/Grammar.pm
7543             ],
7544             [#Rule _STAR_LIST
7545             'STAR-13', 0,
7546             sub {
7547             #line 192 "lib/RPerl/Grammar.eyp"
7548             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7549             #line 7549 lib/RPerl/Grammar.pm
7550             ],
7551             [#Rule _STAR_LIST
7552             'STAR-14', 2,
7553             sub {
7554             #line 192 "lib/RPerl/Grammar.eyp"
7555             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7556             #line 7556 lib/RPerl/Grammar.pm
7557             ],
7558             [#Rule _STAR_LIST
7559             'STAR-14', 0,
7560             sub {
7561             #line 192 "lib/RPerl/Grammar.eyp"
7562             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7563             #line 7563 lib/RPerl/Grammar.pm
7564             ],
7565             [#Rule _PLUS_LIST
7566             'PLUS-15', 2,
7567             sub {
7568             #line 192 "lib/RPerl/Grammar.eyp"
7569             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7570             #line 7570 lib/RPerl/Grammar.pm
7571             ],
7572             [#Rule _PLUS_LIST
7573             'PLUS-15', 1,
7574             sub {
7575             #line 192 "lib/RPerl/Grammar.eyp"
7576             goto &Parse::Eyapp::Driver::YYActionforT_single }
7577             #line 7577 lib/RPerl/Grammar.pm
7578             ],
7579             [#Rule Package_36
7580             'Package', 7,
7581             sub {
7582             #line 24 "lib/RPerl/Grammar.eyp"
7583              
7584             my $self = shift;
7585             my $name = $self->YYName();
7586             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7587             }
7588             #line 7588 lib/RPerl/Grammar.pm
7589             ],
7590             [#Rule _OPTIONAL
7591             'OPTIONAL-16', 1,
7592             sub {
7593             #line 193 "lib/RPerl/Grammar.eyp"
7594             goto &Parse::Eyapp::Driver::YYActionforT_single }
7595             #line 7595 lib/RPerl/Grammar.pm
7596             ],
7597             [#Rule _OPTIONAL
7598             'OPTIONAL-16', 0,
7599             sub {
7600             #line 193 "lib/RPerl/Grammar.eyp"
7601             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7602             #line 7602 lib/RPerl/Grammar.pm
7603             ],
7604             [#Rule Header_39
7605             'Header', 5,
7606             sub {
7607             #line 24 "lib/RPerl/Grammar.eyp"
7608              
7609             my $self = shift;
7610             my $name = $self->YYName();
7611             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7612             }
7613             #line 7613 lib/RPerl/Grammar.pm
7614             ],
7615             [#Rule _PLUS_LIST
7616             'PLUS-17', 2,
7617             sub {
7618             #line 194 "lib/RPerl/Grammar.eyp"
7619             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7620             #line 7620 lib/RPerl/Grammar.pm
7621             ],
7622             [#Rule _PLUS_LIST
7623             'PLUS-17', 1,
7624             sub {
7625             #line 194 "lib/RPerl/Grammar.eyp"
7626             goto &Parse::Eyapp::Driver::YYActionforT_single }
7627             #line 7627 lib/RPerl/Grammar.pm
7628             ],
7629             [#Rule Critic_42
7630             'Critic', 3,
7631             sub {
7632             #line 24 "lib/RPerl/Grammar.eyp"
7633              
7634             my $self = shift;
7635             my $name = $self->YYName();
7636             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7637             }
7638             #line 7638 lib/RPerl/Grammar.pm
7639             ],
7640             [#Rule _PAREN
7641             'PAREN-18', 3,
7642             sub {
7643             #line 195 "lib/RPerl/Grammar.eyp"
7644             goto &Parse::Eyapp::Driver::YYActionforParenthesis}
7645             #line 7645 lib/RPerl/Grammar.pm
7646             ],
7647             [#Rule _OPTIONAL
7648             'OPTIONAL-19', 1,
7649             sub {
7650             #line 195 "lib/RPerl/Grammar.eyp"
7651             goto &Parse::Eyapp::Driver::YYActionforT_single }
7652             #line 7652 lib/RPerl/Grammar.pm
7653             ],
7654             [#Rule _OPTIONAL
7655             'OPTIONAL-19', 0,
7656             sub {
7657             #line 195 "lib/RPerl/Grammar.eyp"
7658             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7659             #line 7659 lib/RPerl/Grammar.pm
7660             ],
7661             [#Rule _PAREN
7662             'PAREN-20', 3,
7663             sub {
7664             #line 195 "lib/RPerl/Grammar.eyp"
7665             goto &Parse::Eyapp::Driver::YYActionforParenthesis}
7666             #line 7666 lib/RPerl/Grammar.pm
7667             ],
7668             [#Rule _OPTIONAL
7669             'OPTIONAL-21', 1,
7670             sub {
7671             #line 195 "lib/RPerl/Grammar.eyp"
7672             goto &Parse::Eyapp::Driver::YYActionforT_single }
7673             #line 7673 lib/RPerl/Grammar.pm
7674             ],
7675             [#Rule _OPTIONAL
7676             'OPTIONAL-21', 0,
7677             sub {
7678             #line 195 "lib/RPerl/Grammar.eyp"
7679             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7680             #line 7680 lib/RPerl/Grammar.pm
7681             ],
7682             [#Rule Exports_49
7683             'Exports', 3,
7684             sub {
7685             #line 24 "lib/RPerl/Grammar.eyp"
7686              
7687             my $self = shift;
7688             my $name = $self->YYName();
7689             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7690             }
7691             #line 7691 lib/RPerl/Grammar.pm
7692             ],
7693             [#Rule Include_50
7694             'Include', 3,
7695             sub {
7696             #line 24 "lib/RPerl/Grammar.eyp"
7697              
7698             my $self = shift;
7699             my $name = $self->YYName();
7700             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7701             }
7702             #line 7702 lib/RPerl/Grammar.pm
7703             ],
7704             [#Rule Include_51
7705             'Include', 4,
7706             sub {
7707             #line 24 "lib/RPerl/Grammar.eyp"
7708              
7709             my $self = shift;
7710             my $name = $self->YYName();
7711             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7712             }
7713             #line 7713 lib/RPerl/Grammar.pm
7714             ],
7715             [#Rule Constant_52
7716             'Constant', 6,
7717             sub {
7718             #line 24 "lib/RPerl/Grammar.eyp"
7719              
7720             my $self = shift;
7721             my $name = $self->YYName();
7722             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7723             }
7724             #line 7724 lib/RPerl/Grammar.pm
7725             ],
7726             [#Rule _OPTIONAL
7727             'OPTIONAL-22', 1,
7728             sub {
7729             #line 201 "lib/RPerl/Grammar.eyp"
7730             goto &Parse::Eyapp::Driver::YYActionforT_single }
7731             #line 7731 lib/RPerl/Grammar.pm
7732             ],
7733             [#Rule _OPTIONAL
7734             'OPTIONAL-22', 0,
7735             sub {
7736             #line 201 "lib/RPerl/Grammar.eyp"
7737             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7738             #line 7738 lib/RPerl/Grammar.pm
7739             ],
7740             [#Rule _STAR_LIST
7741             'STAR-23', 2,
7742             sub {
7743             #line 201 "lib/RPerl/Grammar.eyp"
7744             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7745             #line 7745 lib/RPerl/Grammar.pm
7746             ],
7747             [#Rule _STAR_LIST
7748             'STAR-23', 0,
7749             sub {
7750             #line 201 "lib/RPerl/Grammar.eyp"
7751             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7752             #line 7752 lib/RPerl/Grammar.pm
7753             ],
7754             [#Rule Subroutine_57
7755             'Subroutine', 12,
7756             sub {
7757             #line 24 "lib/RPerl/Grammar.eyp"
7758              
7759             my $self = shift;
7760             my $name = $self->YYName();
7761             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7762             }
7763             #line 7763 lib/RPerl/Grammar.pm
7764             ],
7765             [#Rule _PAREN
7766             'PAREN-24', 4,
7767             sub {
7768             #line 202 "lib/RPerl/Grammar.eyp"
7769             goto &Parse::Eyapp::Driver::YYActionforParenthesis}
7770             #line 7770 lib/RPerl/Grammar.pm
7771             ],
7772             [#Rule _STAR_LIST
7773             'STAR-25', 2,
7774             sub {
7775             #line 202 "lib/RPerl/Grammar.eyp"
7776             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7777             #line 7777 lib/RPerl/Grammar.pm
7778             ],
7779             [#Rule _STAR_LIST
7780             'STAR-25', 0,
7781             sub {
7782             #line 202 "lib/RPerl/Grammar.eyp"
7783             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7784             #line 7784 lib/RPerl/Grammar.pm
7785             ],
7786             [#Rule SubroutineArguments_61
7787             'SubroutineArguments', 7,
7788             sub {
7789             #line 24 "lib/RPerl/Grammar.eyp"
7790              
7791             my $self = shift;
7792             my $name = $self->YYName();
7793             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7794             }
7795             #line 7795 lib/RPerl/Grammar.pm
7796             ],
7797             [#Rule _STAR_LIST
7798             'STAR-26', 2,
7799             sub {
7800             #line 203 "lib/RPerl/Grammar.eyp"
7801             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7802             #line 7802 lib/RPerl/Grammar.pm
7803             ],
7804             [#Rule _STAR_LIST
7805             'STAR-26', 0,
7806             sub {
7807             #line 203 "lib/RPerl/Grammar.eyp"
7808             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7809             #line 7809 lib/RPerl/Grammar.pm
7810             ],
7811             [#Rule _OPTIONAL
7812             'OPTIONAL-27', 1,
7813             sub {
7814             #line 203 "lib/RPerl/Grammar.eyp"
7815             goto &Parse::Eyapp::Driver::YYActionforT_single }
7816             #line 7816 lib/RPerl/Grammar.pm
7817             ],
7818             [#Rule _OPTIONAL
7819             'OPTIONAL-27', 0,
7820             sub {
7821             #line 203 "lib/RPerl/Grammar.eyp"
7822             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7823             #line 7823 lib/RPerl/Grammar.pm
7824             ],
7825             [#Rule _STAR_LIST
7826             'STAR-28', 2,
7827             sub {
7828             #line 203 "lib/RPerl/Grammar.eyp"
7829             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7830             #line 7830 lib/RPerl/Grammar.pm
7831             ],
7832             [#Rule _STAR_LIST
7833             'STAR-28', 0,
7834             sub {
7835             #line 203 "lib/RPerl/Grammar.eyp"
7836             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7837             #line 7837 lib/RPerl/Grammar.pm
7838             ],
7839             [#Rule _STAR_LIST
7840             'STAR-29', 2,
7841             sub {
7842             #line 203 "lib/RPerl/Grammar.eyp"
7843             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7844             #line 7844 lib/RPerl/Grammar.pm
7845             ],
7846             [#Rule _STAR_LIST
7847             'STAR-29', 0,
7848             sub {
7849             #line 203 "lib/RPerl/Grammar.eyp"
7850             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7851             #line 7851 lib/RPerl/Grammar.pm
7852             ],
7853             [#Rule _STAR_LIST
7854             'STAR-30', 2,
7855             sub {
7856             #line 203 "lib/RPerl/Grammar.eyp"
7857             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7858             #line 7858 lib/RPerl/Grammar.pm
7859             ],
7860             [#Rule _STAR_LIST
7861             'STAR-30', 0,
7862             sub {
7863             #line 203 "lib/RPerl/Grammar.eyp"
7864             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7865             #line 7865 lib/RPerl/Grammar.pm
7866             ],
7867             [#Rule Class_72
7868             'Class', 13,
7869             sub {
7870             #line 24 "lib/RPerl/Grammar.eyp"
7871              
7872             my $self = shift;
7873             my $name = $self->YYName();
7874             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7875             }
7876             #line 7876 lib/RPerl/Grammar.pm
7877             ],
7878             [#Rule _PAREN
7879             'PAREN-31', 2,
7880             sub {
7881             #line 204 "lib/RPerl/Grammar.eyp"
7882             goto &Parse::Eyapp::Driver::YYActionforParenthesis}
7883             #line 7883 lib/RPerl/Grammar.pm
7884             ],
7885             [#Rule _STAR_LIST
7886             'STAR-32', 2,
7887             sub {
7888             #line 204 "lib/RPerl/Grammar.eyp"
7889             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7890             #line 7890 lib/RPerl/Grammar.pm
7891             ],
7892             [#Rule _STAR_LIST
7893             'STAR-32', 0,
7894             sub {
7895             #line 204 "lib/RPerl/Grammar.eyp"
7896             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7897             #line 7897 lib/RPerl/Grammar.pm
7898             ],
7899             [#Rule Properties_76
7900             'Properties', 7,
7901             sub {
7902             #line 24 "lib/RPerl/Grammar.eyp"
7903              
7904             my $self = shift;
7905             my $name = $self->YYName();
7906             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7907             }
7908             #line 7908 lib/RPerl/Grammar.pm
7909             ],
7910             [#Rule Properties_77
7911             'Properties', 5,
7912             sub {
7913             #line 24 "lib/RPerl/Grammar.eyp"
7914              
7915             my $self = shift;
7916             my $name = $self->YYName();
7917             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7918             }
7919             #line 7919 lib/RPerl/Grammar.pm
7920             ],
7921             [#Rule _OPTIONAL
7922             'OPTIONAL-33', 1,
7923             sub {
7924             #line 206 "lib/RPerl/Grammar.eyp"
7925             goto &Parse::Eyapp::Driver::YYActionforT_single }
7926             #line 7926 lib/RPerl/Grammar.pm
7927             ],
7928             [#Rule _OPTIONAL
7929             'OPTIONAL-33', 0,
7930             sub {
7931             #line 206 "lib/RPerl/Grammar.eyp"
7932             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7933             #line 7933 lib/RPerl/Grammar.pm
7934             ],
7935             [#Rule _STAR_LIST
7936             'STAR-34', 2,
7937             sub {
7938             #line 206 "lib/RPerl/Grammar.eyp"
7939             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7940             #line 7940 lib/RPerl/Grammar.pm
7941             ],
7942             [#Rule _STAR_LIST
7943             'STAR-34', 0,
7944             sub {
7945             #line 206 "lib/RPerl/Grammar.eyp"
7946             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7947             #line 7947 lib/RPerl/Grammar.pm
7948             ],
7949             [#Rule Method_82
7950             'Method', 12,
7951             sub {
7952             #line 24 "lib/RPerl/Grammar.eyp"
7953              
7954             my $self = shift;
7955             my $name = $self->YYName();
7956             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7957             }
7958             #line 7958 lib/RPerl/Grammar.pm
7959             ],
7960             [#Rule _PAREN
7961             'PAREN-35', 4,
7962             sub {
7963             #line 207 "lib/RPerl/Grammar.eyp"
7964             goto &Parse::Eyapp::Driver::YYActionforParenthesis}
7965             #line 7965 lib/RPerl/Grammar.pm
7966             ],
7967             [#Rule _STAR_LIST
7968             'STAR-36', 2,
7969             sub {
7970             #line 207 "lib/RPerl/Grammar.eyp"
7971             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
7972             #line 7972 lib/RPerl/Grammar.pm
7973             ],
7974             [#Rule _STAR_LIST
7975             'STAR-36', 0,
7976             sub {
7977             #line 207 "lib/RPerl/Grammar.eyp"
7978             goto &Parse::Eyapp::Driver::YYActionforT_empty }
7979             #line 7979 lib/RPerl/Grammar.pm
7980             ],
7981             [#Rule MethodArguments_86
7982             'MethodArguments', 7,
7983             sub {
7984             #line 24 "lib/RPerl/Grammar.eyp"
7985              
7986             my $self = shift;
7987             my $name = $self->YYName();
7988             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
7989             }
7990             #line 7990 lib/RPerl/Grammar.pm
7991             ],
7992             [#Rule SubroutineOrMethod_87
7993             'SubroutineOrMethod', 1,
7994             sub {
7995             #line 24 "lib/RPerl/Grammar.eyp"
7996              
7997             my $self = shift;
7998             my $name = $self->YYName();
7999             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8000             }
8001             #line 8001 lib/RPerl/Grammar.pm
8002             ],
8003             [#Rule SubroutineOrMethod_88
8004             'SubroutineOrMethod', 1,
8005             sub {
8006             #line 24 "lib/RPerl/Grammar.eyp"
8007              
8008             my $self = shift;
8009             my $name = $self->YYName();
8010             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8011             }
8012             #line 8012 lib/RPerl/Grammar.pm
8013             ],
8014             [#Rule Operation_89
8015             'Operation', 2,
8016             sub {
8017             #line 24 "lib/RPerl/Grammar.eyp"
8018              
8019             my $self = shift;
8020             my $name = $self->YYName();
8021             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8022             }
8023             #line 8023 lib/RPerl/Grammar.pm
8024             ],
8025             [#Rule Operation_90
8026             'Operation', 1,
8027             sub {
8028             #line 24 "lib/RPerl/Grammar.eyp"
8029              
8030             my $self = shift;
8031             my $name = $self->YYName();
8032             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8033             }
8034             #line 8034 lib/RPerl/Grammar.pm
8035             ],
8036             [#Rule Operation_91
8037             'Operation', 1,
8038             sub {
8039             #line 24 "lib/RPerl/Grammar.eyp"
8040              
8041             my $self = shift;
8042             my $name = $self->YYName();
8043             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8044             }
8045             #line 8045 lib/RPerl/Grammar.pm
8046             ],
8047             [#Rule Operation_92
8048             'Operation', 1,
8049             sub {
8050             #line 24 "lib/RPerl/Grammar.eyp"
8051              
8052             my $self = shift;
8053             my $name = $self->YYName();
8054             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8055             }
8056             #line 8056 lib/RPerl/Grammar.pm
8057             ],
8058             [#Rule Operator_93
8059             'Operator', 5,
8060             sub {
8061             #line 24 "lib/RPerl/Grammar.eyp"
8062              
8063             my $self = shift;
8064             my $name = $self->YYName();
8065             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8066             }
8067             #line 8067 lib/RPerl/Grammar.pm
8068             ],
8069             [#Rule Operator_94
8070             'Operator', 2,
8071             sub {
8072             #line 24 "lib/RPerl/Grammar.eyp"
8073              
8074             my $self = shift;
8075             my $name = $self->YYName();
8076             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8077             }
8078             #line 8078 lib/RPerl/Grammar.pm
8079             ],
8080             [#Rule Operator_95
8081             'Operator', 6,
8082             sub {
8083             #line 24 "lib/RPerl/Grammar.eyp"
8084              
8085             my $self = shift;
8086             my $name = $self->YYName();
8087             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8088             }
8089             #line 8089 lib/RPerl/Grammar.pm
8090             ],
8091             [#Rule Operator_96
8092             'Operator', 8,
8093             sub {
8094             #line 24 "lib/RPerl/Grammar.eyp"
8095              
8096             my $self = shift;
8097             my $name = $self->YYName();
8098             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8099             }
8100             #line 8100 lib/RPerl/Grammar.pm
8101             ],
8102             [#Rule Operator_97
8103             'Operator', 2,
8104             sub {
8105             #line 24 "lib/RPerl/Grammar.eyp"
8106              
8107             my $self = shift;
8108             my $name = $self->YYName();
8109             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8110             }
8111             #line 8111 lib/RPerl/Grammar.pm
8112             ],
8113             [#Rule Operator_98
8114             'Operator', 2,
8115             sub {
8116             #line 24 "lib/RPerl/Grammar.eyp"
8117              
8118             my $self = shift;
8119             my $name = $self->YYName();
8120             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8121             }
8122             #line 8122 lib/RPerl/Grammar.pm
8123             ],
8124             [#Rule Operator_99
8125             'Operator', 2,
8126             sub {
8127             #line 24 "lib/RPerl/Grammar.eyp"
8128              
8129             my $self = shift;
8130             my $name = $self->YYName();
8131             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8132             }
8133             #line 8133 lib/RPerl/Grammar.pm
8134             ],
8135             [#Rule Operator_100
8136             'Operator', 3,
8137             sub {
8138             #line 24 "lib/RPerl/Grammar.eyp"
8139              
8140             my $self = shift;
8141             my $name = $self->YYName();
8142             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8143             }
8144             #line 8144 lib/RPerl/Grammar.pm
8145             ],
8146             [#Rule Operator_101
8147             'Operator', 3,
8148             sub {
8149             #line 24 "lib/RPerl/Grammar.eyp"
8150              
8151             my $self = shift;
8152             my $name = $self->YYName();
8153             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8154             }
8155             #line 8155 lib/RPerl/Grammar.pm
8156             ],
8157             [#Rule Operator_102
8158             'Operator', 2,
8159             sub {
8160             #line 24 "lib/RPerl/Grammar.eyp"
8161              
8162             my $self = shift;
8163             my $name = $self->YYName();
8164             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8165             }
8166             #line 8166 lib/RPerl/Grammar.pm
8167             ],
8168             [#Rule Operator_103
8169             'Operator', 3,
8170             sub {
8171             #line 24 "lib/RPerl/Grammar.eyp"
8172              
8173             my $self = shift;
8174             my $name = $self->YYName();
8175             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8176             }
8177             #line 8177 lib/RPerl/Grammar.pm
8178             ],
8179             [#Rule Operator_104
8180             'Operator', 3,
8181             sub {
8182             #line 24 "lib/RPerl/Grammar.eyp"
8183              
8184             my $self = shift;
8185             my $name = $self->YYName();
8186             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8187             }
8188             #line 8188 lib/RPerl/Grammar.pm
8189             ],
8190             [#Rule Operator_105
8191             'Operator', 3,
8192             sub {
8193             #line 24 "lib/RPerl/Grammar.eyp"
8194              
8195             my $self = shift;
8196             my $name = $self->YYName();
8197             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8198             }
8199             #line 8199 lib/RPerl/Grammar.pm
8200             ],
8201             [#Rule Operator_106
8202             'Operator', 3,
8203             sub {
8204             #line 24 "lib/RPerl/Grammar.eyp"
8205              
8206             my $self = shift;
8207             my $name = $self->YYName();
8208             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8209             }
8210             #line 8210 lib/RPerl/Grammar.pm
8211             ],
8212             [#Rule Operator_107
8213             'Operator', 3,
8214             sub {
8215             #line 24 "lib/RPerl/Grammar.eyp"
8216              
8217             my $self = shift;
8218             my $name = $self->YYName();
8219             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8220             }
8221             #line 8221 lib/RPerl/Grammar.pm
8222             ],
8223             [#Rule Operator_108
8224             'Operator', 3,
8225             sub {
8226             #line 24 "lib/RPerl/Grammar.eyp"
8227              
8228             my $self = shift;
8229             my $name = $self->YYName();
8230             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8231             }
8232             #line 8232 lib/RPerl/Grammar.pm
8233             ],
8234             [#Rule Operator_109
8235             'Operator', 3,
8236             sub {
8237             #line 24 "lib/RPerl/Grammar.eyp"
8238              
8239             my $self = shift;
8240             my $name = $self->YYName();
8241             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8242             }
8243             #line 8243 lib/RPerl/Grammar.pm
8244             ],
8245             [#Rule Operator_110
8246             'Operator', 2,
8247             sub {
8248             #line 24 "lib/RPerl/Grammar.eyp"
8249              
8250             my $self = shift;
8251             my $name = $self->YYName();
8252             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8253             }
8254             #line 8254 lib/RPerl/Grammar.pm
8255             ],
8256             [#Rule Operator_111
8257             'Operator', 1,
8258             sub {
8259             #line 24 "lib/RPerl/Grammar.eyp"
8260              
8261             my $self = shift;
8262             my $name = $self->YYName();
8263             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8264             }
8265             #line 8265 lib/RPerl/Grammar.pm
8266             ],
8267             [#Rule Operator_112
8268             'Operator', 3,
8269             sub {
8270             #line 24 "lib/RPerl/Grammar.eyp"
8271              
8272             my $self = shift;
8273             my $name = $self->YYName();
8274             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8275             }
8276             #line 8276 lib/RPerl/Grammar.pm
8277             ],
8278             [#Rule Operator_113
8279             'Operator', 3,
8280             sub {
8281             #line 24 "lib/RPerl/Grammar.eyp"
8282              
8283             my $self = shift;
8284             my $name = $self->YYName();
8285             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8286             }
8287             #line 8287 lib/RPerl/Grammar.pm
8288             ],
8289             [#Rule Operator_114
8290             'Operator', 3,
8291             sub {
8292             #line 24 "lib/RPerl/Grammar.eyp"
8293              
8294             my $self = shift;
8295             my $name = $self->YYName();
8296             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8297             }
8298             #line 8298 lib/RPerl/Grammar.pm
8299             ],
8300             [#Rule Operator_115
8301             'Operator', 3,
8302             sub {
8303             #line 24 "lib/RPerl/Grammar.eyp"
8304              
8305             my $self = shift;
8306             my $name = $self->YYName();
8307             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8308             }
8309             #line 8309 lib/RPerl/Grammar.pm
8310             ],
8311             [#Rule Operator_116
8312             'Operator', 3,
8313             sub {
8314             #line 24 "lib/RPerl/Grammar.eyp"
8315              
8316             my $self = shift;
8317             my $name = $self->YYName();
8318             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8319             }
8320             #line 8320 lib/RPerl/Grammar.pm
8321             ],
8322             [#Rule Operator_117
8323             'Operator', 3,
8324             sub {
8325             #line 24 "lib/RPerl/Grammar.eyp"
8326              
8327             my $self = shift;
8328             my $name = $self->YYName();
8329             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8330             }
8331             #line 8331 lib/RPerl/Grammar.pm
8332             ],
8333             [#Rule Operator_118
8334             'Operator', 3,
8335             sub {
8336             #line 24 "lib/RPerl/Grammar.eyp"
8337              
8338             my $self = shift;
8339             my $name = $self->YYName();
8340             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8341             }
8342             #line 8342 lib/RPerl/Grammar.pm
8343             ],
8344             [#Rule Operator_119
8345             'Operator', 5,
8346             sub {
8347             #line 24 "lib/RPerl/Grammar.eyp"
8348              
8349             my $self = shift;
8350             my $name = $self->YYName();
8351             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8352             }
8353             #line 8353 lib/RPerl/Grammar.pm
8354             ],
8355             [#Rule Operator_120
8356             'Operator', 3,
8357             sub {
8358             #line 24 "lib/RPerl/Grammar.eyp"
8359              
8360             my $self = shift;
8361             my $name = $self->YYName();
8362             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8363             }
8364             #line 8364 lib/RPerl/Grammar.pm
8365             ],
8366             [#Rule Operator_121
8367             'Operator', 2,
8368             sub {
8369             #line 24 "lib/RPerl/Grammar.eyp"
8370              
8371             my $self = shift;
8372             my $name = $self->YYName();
8373             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8374             }
8375             #line 8375 lib/RPerl/Grammar.pm
8376             ],
8377             [#Rule Operator_122
8378             'Operator', 3,
8379             sub {
8380             #line 24 "lib/RPerl/Grammar.eyp"
8381              
8382             my $self = shift;
8383             my $name = $self->YYName();
8384             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8385             }
8386             #line 8386 lib/RPerl/Grammar.pm
8387             ],
8388             [#Rule Operator_123
8389             'Operator', 3,
8390             sub {
8391             #line 24 "lib/RPerl/Grammar.eyp"
8392              
8393             my $self = shift;
8394             my $name = $self->YYName();
8395             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8396             }
8397             #line 8397 lib/RPerl/Grammar.pm
8398             ],
8399             [#Rule _PAREN
8400             'PAREN-37', 1,
8401             sub {
8402             #line 233 "lib/RPerl/Grammar.eyp"
8403             goto &Parse::Eyapp::Driver::YYActionforParenthesis}
8404             #line 8404 lib/RPerl/Grammar.pm
8405             ],
8406             [#Rule _OPTIONAL
8407             'OPTIONAL-38', 1,
8408             sub {
8409             #line 233 "lib/RPerl/Grammar.eyp"
8410             goto &Parse::Eyapp::Driver::YYActionforT_single }
8411             #line 8411 lib/RPerl/Grammar.pm
8412             ],
8413             [#Rule _OPTIONAL
8414             'OPTIONAL-38', 0,
8415             sub {
8416             #line 233 "lib/RPerl/Grammar.eyp"
8417             goto &Parse::Eyapp::Driver::YYActionforT_empty }
8418             #line 8418 lib/RPerl/Grammar.pm
8419             ],
8420             [#Rule _OPTIONAL
8421             'OPTIONAL-39', 1,
8422             sub {
8423             #line 234 "lib/RPerl/Grammar.eyp"
8424             goto &Parse::Eyapp::Driver::YYActionforT_single }
8425             #line 8425 lib/RPerl/Grammar.pm
8426             ],
8427             [#Rule _OPTIONAL
8428             'OPTIONAL-39', 0,
8429             sub {
8430             #line 234 "lib/RPerl/Grammar.eyp"
8431             goto &Parse::Eyapp::Driver::YYActionforT_empty }
8432             #line 8432 lib/RPerl/Grammar.pm
8433             ],
8434             [#Rule OperatorVoid_129
8435             'OperatorVoid', 4,
8436             sub {
8437             #line 24 "lib/RPerl/Grammar.eyp"
8438              
8439             my $self = shift;
8440             my $name = $self->YYName();
8441             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8442             }
8443             #line 8443 lib/RPerl/Grammar.pm
8444             ],
8445             [#Rule OperatorVoid_130
8446             'OperatorVoid', 4,
8447             sub {
8448             #line 24 "lib/RPerl/Grammar.eyp"
8449              
8450             my $self = shift;
8451             my $name = $self->YYName();
8452             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8453             }
8454             #line 8454 lib/RPerl/Grammar.pm
8455             ],
8456             [#Rule OperatorVoid_131
8457             'OperatorVoid', 1,
8458             sub {
8459             #line 24 "lib/RPerl/Grammar.eyp"
8460              
8461             my $self = shift;
8462             my $name = $self->YYName();
8463             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8464             }
8465             #line 8465 lib/RPerl/Grammar.pm
8466             ],
8467             [#Rule OperatorVoid_132
8468             'OperatorVoid', 4,
8469             sub {
8470             #line 24 "lib/RPerl/Grammar.eyp"
8471              
8472             my $self = shift;
8473             my $name = $self->YYName();
8474             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8475             }
8476             #line 8476 lib/RPerl/Grammar.pm
8477             ],
8478             [#Rule OperatorVoid_133
8479             'OperatorVoid', 3,
8480             sub {
8481             #line 24 "lib/RPerl/Grammar.eyp"
8482              
8483             my $self = shift;
8484             my $name = $self->YYName();
8485             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8486             }
8487             #line 8487 lib/RPerl/Grammar.pm
8488             ],
8489             [#Rule OperatorVoid_134
8490             'OperatorVoid', 5,
8491             sub {
8492             #line 24 "lib/RPerl/Grammar.eyp"
8493              
8494             my $self = shift;
8495             my $name = $self->YYName();
8496             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8497             }
8498             #line 8498 lib/RPerl/Grammar.pm
8499             ],
8500             [#Rule OperatorVoid_135
8501             'OperatorVoid', 1,
8502             sub {
8503             #line 24 "lib/RPerl/Grammar.eyp"
8504              
8505             my $self = shift;
8506             my $name = $self->YYName();
8507             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8508             }
8509             #line 8509 lib/RPerl/Grammar.pm
8510             ],
8511             [#Rule OperatorVoid_136
8512             'OperatorVoid', 3,
8513             sub {
8514             #line 24 "lib/RPerl/Grammar.eyp"
8515              
8516             my $self = shift;
8517             my $name = $self->YYName();
8518             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8519             }
8520             #line 8520 lib/RPerl/Grammar.pm
8521             ],
8522             [#Rule _OPTIONAL
8523             'OPTIONAL-40', 1,
8524             sub {
8525             #line 236 "lib/RPerl/Grammar.eyp"
8526             goto &Parse::Eyapp::Driver::YYActionforT_single }
8527             #line 8527 lib/RPerl/Grammar.pm
8528             ],
8529             [#Rule _OPTIONAL
8530             'OPTIONAL-40', 0,
8531             sub {
8532             #line 236 "lib/RPerl/Grammar.eyp"
8533             goto &Parse::Eyapp::Driver::YYActionforT_empty }
8534             #line 8534 lib/RPerl/Grammar.pm
8535             ],
8536             [#Rule _OPTIONAL
8537             'OPTIONAL-41', 1,
8538             sub {
8539             #line 237 "lib/RPerl/Grammar.eyp"
8540             goto &Parse::Eyapp::Driver::YYActionforT_single }
8541             #line 8541 lib/RPerl/Grammar.pm
8542             ],
8543             [#Rule _OPTIONAL
8544             'OPTIONAL-41', 0,
8545             sub {
8546             #line 237 "lib/RPerl/Grammar.eyp"
8547             goto &Parse::Eyapp::Driver::YYActionforT_empty }
8548             #line 8548 lib/RPerl/Grammar.pm
8549             ],
8550             [#Rule _OPTIONAL
8551             'OPTIONAL-42', 1,
8552             sub {
8553             #line 237 "lib/RPerl/Grammar.eyp"
8554             goto &Parse::Eyapp::Driver::YYActionforT_single }
8555             #line 8555 lib/RPerl/Grammar.pm
8556             ],
8557             [#Rule _OPTIONAL
8558             'OPTIONAL-42', 0,
8559             sub {
8560             #line 237 "lib/RPerl/Grammar.eyp"
8561             goto &Parse::Eyapp::Driver::YYActionforT_empty }
8562             #line 8562 lib/RPerl/Grammar.pm
8563             ],
8564             [#Rule Expression_143
8565             'Expression', 1,
8566             sub {
8567             #line 24 "lib/RPerl/Grammar.eyp"
8568              
8569             my $self = shift;
8570             my $name = $self->YYName();
8571             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8572             }
8573             #line 8573 lib/RPerl/Grammar.pm
8574             ],
8575             [#Rule Expression_144
8576             'Expression', 3,
8577             sub {
8578             #line 24 "lib/RPerl/Grammar.eyp"
8579              
8580             my $self = shift;
8581             my $name = $self->YYName();
8582             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8583             }
8584             #line 8584 lib/RPerl/Grammar.pm
8585             ],
8586             [#Rule Expression_145
8587             'Expression', 1,
8588             sub {
8589             #line 24 "lib/RPerl/Grammar.eyp"
8590              
8591             my $self = shift;
8592             my $name = $self->YYName();
8593             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8594             }
8595             #line 8595 lib/RPerl/Grammar.pm
8596             ],
8597             [#Rule Expression_146
8598             'Expression', 4,
8599             sub {
8600             #line 24 "lib/RPerl/Grammar.eyp"
8601              
8602             my $self = shift;
8603             my $name = $self->YYName();
8604             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8605             }
8606             #line 8606 lib/RPerl/Grammar.pm
8607             ],
8608             [#Rule Expression_147
8609             'Expression', 5,
8610             sub {
8611             #line 24 "lib/RPerl/Grammar.eyp"
8612              
8613             my $self = shift;
8614             my $name = $self->YYName();
8615             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8616             }
8617             #line 8617 lib/RPerl/Grammar.pm
8618             ],
8619             [#Rule Expression_148
8620             'Expression', 4,
8621             sub {
8622             #line 24 "lib/RPerl/Grammar.eyp"
8623              
8624             my $self = shift;
8625             my $name = $self->YYName();
8626             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8627             }
8628             #line 8628 lib/RPerl/Grammar.pm
8629             ],
8630             [#Rule SubExpression_149
8631             'SubExpression', 1,
8632             sub {
8633             #line 24 "lib/RPerl/Grammar.eyp"
8634              
8635             my $self = shift;
8636             my $name = $self->YYName();
8637             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8638             }
8639             #line 8639 lib/RPerl/Grammar.pm
8640             ],
8641             [#Rule SubExpression_150
8642             'SubExpression', 1,
8643             sub {
8644             #line 24 "lib/RPerl/Grammar.eyp"
8645              
8646             my $self = shift;
8647             my $name = $self->YYName();
8648             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8649             }
8650             #line 8650 lib/RPerl/Grammar.pm
8651             ],
8652             [#Rule SubExpression_151
8653             'SubExpression', 1,
8654             sub {
8655             #line 24 "lib/RPerl/Grammar.eyp"
8656              
8657             my $self = shift;
8658             my $name = $self->YYName();
8659             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8660             }
8661             #line 8661 lib/RPerl/Grammar.pm
8662             ],
8663             [#Rule SubExpression_152
8664             'SubExpression', 1,
8665             sub {
8666             #line 24 "lib/RPerl/Grammar.eyp"
8667              
8668             my $self = shift;
8669             my $name = $self->YYName();
8670             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8671             }
8672             #line 8672 lib/RPerl/Grammar.pm
8673             ],
8674             [#Rule SubExpression_153
8675             'SubExpression', 1,
8676             sub {
8677             #line 24 "lib/RPerl/Grammar.eyp"
8678              
8679             my $self = shift;
8680             my $name = $self->YYName();
8681             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8682             }
8683             #line 8683 lib/RPerl/Grammar.pm
8684             ],
8685             [#Rule SubExpression_154
8686             'SubExpression', 1,
8687             sub {
8688             #line 24 "lib/RPerl/Grammar.eyp"
8689              
8690             my $self = shift;
8691             my $name = $self->YYName();
8692             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8693             }
8694             #line 8694 lib/RPerl/Grammar.pm
8695             ],
8696             [#Rule SubExpression_155
8697             'SubExpression', 1,
8698             sub {
8699             #line 24 "lib/RPerl/Grammar.eyp"
8700              
8701             my $self = shift;
8702             my $name = $self->YYName();
8703             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8704             }
8705             #line 8705 lib/RPerl/Grammar.pm
8706             ],
8707             [#Rule SubExpression_156
8708             'SubExpression', 1,
8709             sub {
8710             #line 24 "lib/RPerl/Grammar.eyp"
8711              
8712             my $self = shift;
8713             my $name = $self->YYName();
8714             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8715             }
8716             #line 8716 lib/RPerl/Grammar.pm
8717             ],
8718             [#Rule SubExpression_157
8719             'SubExpression', 3,
8720             sub {
8721             #line 24 "lib/RPerl/Grammar.eyp"
8722              
8723             my $self = shift;
8724             my $name = $self->YYName();
8725             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8726             }
8727             #line 8727 lib/RPerl/Grammar.pm
8728             ],
8729             [#Rule SubExpressionOrInput_158
8730             'SubExpressionOrInput', 1,
8731             sub {
8732             #line 24 "lib/RPerl/Grammar.eyp"
8733              
8734             my $self = shift;
8735             my $name = $self->YYName();
8736             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8737             }
8738             #line 8738 lib/RPerl/Grammar.pm
8739             ],
8740             [#Rule SubExpressionOrInput_159
8741             'SubExpressionOrInput', 1,
8742             sub {
8743             #line 24 "lib/RPerl/Grammar.eyp"
8744              
8745             my $self = shift;
8746             my $name = $self->YYName();
8747             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8748             }
8749             #line 8749 lib/RPerl/Grammar.pm
8750             ],
8751             [#Rule SubExpressionOrInput_160
8752             'SubExpressionOrInput', 1,
8753             sub {
8754             #line 24 "lib/RPerl/Grammar.eyp"
8755              
8756             my $self = shift;
8757             my $name = $self->YYName();
8758             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8759             }
8760             #line 8760 lib/RPerl/Grammar.pm
8761             ],
8762             [#Rule SubExpressionOrVarMod_161
8763             'SubExpressionOrVarMod', 1,
8764             sub {
8765             #line 24 "lib/RPerl/Grammar.eyp"
8766              
8767             my $self = shift;
8768             my $name = $self->YYName();
8769             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8770             }
8771             #line 8771 lib/RPerl/Grammar.pm
8772             ],
8773             [#Rule SubExpressionOrVarMod_162
8774             'SubExpressionOrVarMod', 1,
8775             sub {
8776             #line 24 "lib/RPerl/Grammar.eyp"
8777              
8778             my $self = shift;
8779             my $name = $self->YYName();
8780             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8781             }
8782             #line 8782 lib/RPerl/Grammar.pm
8783             ],
8784             [#Rule _PAREN
8785             'PAREN-43', 2,
8786             sub {
8787             #line 241 "lib/RPerl/Grammar.eyp"
8788             goto &Parse::Eyapp::Driver::YYActionforParenthesis}
8789             #line 8789 lib/RPerl/Grammar.pm
8790             ],
8791             [#Rule _OPTIONAL
8792             'OPTIONAL-44', 1,
8793             sub {
8794             #line 241 "lib/RPerl/Grammar.eyp"
8795             goto &Parse::Eyapp::Driver::YYActionforT_single }
8796             #line 8796 lib/RPerl/Grammar.pm
8797             ],
8798             [#Rule _OPTIONAL
8799             'OPTIONAL-44', 0,
8800             sub {
8801             #line 241 "lib/RPerl/Grammar.eyp"
8802             goto &Parse::Eyapp::Driver::YYActionforT_empty }
8803             #line 8803 lib/RPerl/Grammar.pm
8804             ],
8805             [#Rule Statement_166
8806             'Statement', 1,
8807             sub {
8808             #line 24 "lib/RPerl/Grammar.eyp"
8809              
8810             my $self = shift;
8811             my $name = $self->YYName();
8812             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8813             }
8814             #line 8814 lib/RPerl/Grammar.pm
8815             ],
8816             [#Rule Statement_167
8817             'Statement', 2,
8818             sub {
8819             #line 24 "lib/RPerl/Grammar.eyp"
8820              
8821             my $self = shift;
8822             my $name = $self->YYName();
8823             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8824             }
8825             #line 8825 lib/RPerl/Grammar.pm
8826             ],
8827             [#Rule Statement_168
8828             'Statement', 1,
8829             sub {
8830             #line 24 "lib/RPerl/Grammar.eyp"
8831              
8832             my $self = shift;
8833             my $name = $self->YYName();
8834             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8835             }
8836             #line 8836 lib/RPerl/Grammar.pm
8837             ],
8838             [#Rule Statement_169
8839             'Statement', 1,
8840             sub {
8841             #line 24 "lib/RPerl/Grammar.eyp"
8842              
8843             my $self = shift;
8844             my $name = $self->YYName();
8845             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8846             }
8847             #line 8847 lib/RPerl/Grammar.pm
8848             ],
8849             [#Rule Statement_170
8850             'Statement', 2,
8851             sub {
8852             #line 24 "lib/RPerl/Grammar.eyp"
8853              
8854             my $self = shift;
8855             my $name = $self->YYName();
8856             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8857             }
8858             #line 8858 lib/RPerl/Grammar.pm
8859             ],
8860             [#Rule _PAREN
8861             'PAREN-45', 5,
8862             sub {
8863             #line 242 "lib/RPerl/Grammar.eyp"
8864             goto &Parse::Eyapp::Driver::YYActionforParenthesis}
8865             #line 8865 lib/RPerl/Grammar.pm
8866             ],
8867             [#Rule _STAR_LIST
8868             'STAR-46', 2,
8869             sub {
8870             #line 242 "lib/RPerl/Grammar.eyp"
8871             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
8872             #line 8872 lib/RPerl/Grammar.pm
8873             ],
8874             [#Rule _STAR_LIST
8875             'STAR-46', 0,
8876             sub {
8877             #line 242 "lib/RPerl/Grammar.eyp"
8878             goto &Parse::Eyapp::Driver::YYActionforT_empty }
8879             #line 8879 lib/RPerl/Grammar.pm
8880             ],
8881             [#Rule _PAREN
8882             'PAREN-47', 2,
8883             sub {
8884             #line 242 "lib/RPerl/Grammar.eyp"
8885             goto &Parse::Eyapp::Driver::YYActionforParenthesis}
8886             #line 8886 lib/RPerl/Grammar.pm
8887             ],
8888             [#Rule _OPTIONAL
8889             'OPTIONAL-48', 1,
8890             sub {
8891             #line 242 "lib/RPerl/Grammar.eyp"
8892             goto &Parse::Eyapp::Driver::YYActionforT_single }
8893             #line 8893 lib/RPerl/Grammar.pm
8894             ],
8895             [#Rule _OPTIONAL
8896             'OPTIONAL-48', 0,
8897             sub {
8898             #line 242 "lib/RPerl/Grammar.eyp"
8899             goto &Parse::Eyapp::Driver::YYActionforT_empty }
8900             #line 8900 lib/RPerl/Grammar.pm
8901             ],
8902             [#Rule Conditional_177
8903             'Conditional', 7,
8904             sub {
8905             #line 24 "lib/RPerl/Grammar.eyp"
8906              
8907             my $self = shift;
8908             my $name = $self->YYName();
8909             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8910             }
8911             #line 8911 lib/RPerl/Grammar.pm
8912             ],
8913             [#Rule Loop_178
8914             'Loop', 1,
8915             sub {
8916             #line 24 "lib/RPerl/Grammar.eyp"
8917              
8918             my $self = shift;
8919             my $name = $self->YYName();
8920             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8921             }
8922             #line 8922 lib/RPerl/Grammar.pm
8923             ],
8924             [#Rule Loop_179
8925             'Loop', 1,
8926             sub {
8927             #line 24 "lib/RPerl/Grammar.eyp"
8928              
8929             my $self = shift;
8930             my $name = $self->YYName();
8931             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8932             }
8933             #line 8933 lib/RPerl/Grammar.pm
8934             ],
8935             [#Rule Loop_180
8936             'Loop', 1,
8937             sub {
8938             #line 24 "lib/RPerl/Grammar.eyp"
8939              
8940             my $self = shift;
8941             my $name = $self->YYName();
8942             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8943             }
8944             #line 8944 lib/RPerl/Grammar.pm
8945             ],
8946             [#Rule LoopFor_181
8947             'LoopFor', 10,
8948             sub {
8949             #line 24 "lib/RPerl/Grammar.eyp"
8950              
8951             my $self = shift;
8952             my $name = $self->YYName();
8953             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8954             }
8955             #line 8955 lib/RPerl/Grammar.pm
8956             ],
8957             [#Rule LoopFor_182
8958             'LoopFor', 12,
8959             sub {
8960             #line 24 "lib/RPerl/Grammar.eyp"
8961              
8962             my $self = shift;
8963             my $name = $self->YYName();
8964             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8965             }
8966             #line 8966 lib/RPerl/Grammar.pm
8967             ],
8968             [#Rule LoopForEach_183
8969             'LoopForEach', 8,
8970             sub {
8971             #line 24 "lib/RPerl/Grammar.eyp"
8972              
8973             my $self = shift;
8974             my $name = $self->YYName();
8975             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8976             }
8977             #line 8977 lib/RPerl/Grammar.pm
8978             ],
8979             [#Rule LoopWhile_184
8980             'LoopWhile', 5,
8981             sub {
8982             #line 24 "lib/RPerl/Grammar.eyp"
8983              
8984             my $self = shift;
8985             my $name = $self->YYName();
8986             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8987             }
8988             #line 8988 lib/RPerl/Grammar.pm
8989             ],
8990             [#Rule LoopWhile_185
8991             'LoopWhile', 8,
8992             sub {
8993             #line 24 "lib/RPerl/Grammar.eyp"
8994              
8995             my $self = shift;
8996             my $name = $self->YYName();
8997             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
8998             }
8999             #line 8999 lib/RPerl/Grammar.pm
9000             ],
9001             [#Rule _PLUS_LIST
9002             'PLUS-49', 2,
9003             sub {
9004             #line 248 "lib/RPerl/Grammar.eyp"
9005             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
9006             #line 9006 lib/RPerl/Grammar.pm
9007             ],
9008             [#Rule _PLUS_LIST
9009             'PLUS-49', 1,
9010             sub {
9011             #line 248 "lib/RPerl/Grammar.eyp"
9012             goto &Parse::Eyapp::Driver::YYActionforT_single }
9013             #line 9013 lib/RPerl/Grammar.pm
9014             ],
9015             [#Rule CodeBlock_188
9016             'CodeBlock', 3,
9017             sub {
9018             #line 24 "lib/RPerl/Grammar.eyp"
9019              
9020             my $self = shift;
9021             my $name = $self->YYName();
9022             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9023             }
9024             #line 9024 lib/RPerl/Grammar.pm
9025             ],
9026             [#Rule _STAR_LIST
9027             'STAR-50', 2,
9028             sub {
9029             #line 252 "lib/RPerl/Grammar.eyp"
9030             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
9031             #line 9031 lib/RPerl/Grammar.pm
9032             ],
9033             [#Rule _STAR_LIST
9034             'STAR-50', 0,
9035             sub {
9036             #line 252 "lib/RPerl/Grammar.eyp"
9037             goto &Parse::Eyapp::Driver::YYActionforT_empty }
9038             #line 9038 lib/RPerl/Grammar.pm
9039             ],
9040             [#Rule Variable_191
9041             'Variable', 2,
9042             sub {
9043             #line 24 "lib/RPerl/Grammar.eyp"
9044              
9045             my $self = shift;
9046             my $name = $self->YYName();
9047             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9048             }
9049             #line 9049 lib/RPerl/Grammar.pm
9050             ],
9051             [#Rule VariableRetrieval_192
9052             'VariableRetrieval', 3,
9053             sub {
9054             #line 24 "lib/RPerl/Grammar.eyp"
9055              
9056             my $self = shift;
9057             my $name = $self->YYName();
9058             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9059             }
9060             #line 9060 lib/RPerl/Grammar.pm
9061             ],
9062             [#Rule VariableRetrieval_193
9063             'VariableRetrieval', 3,
9064             sub {
9065             #line 24 "lib/RPerl/Grammar.eyp"
9066              
9067             my $self = shift;
9068             my $name = $self->YYName();
9069             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9070             }
9071             #line 9071 lib/RPerl/Grammar.pm
9072             ],
9073             [#Rule VariableRetrieval_194
9074             'VariableRetrieval', 3,
9075             sub {
9076             #line 24 "lib/RPerl/Grammar.eyp"
9077              
9078             my $self = shift;
9079             my $name = $self->YYName();
9080             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9081             }
9082             #line 9082 lib/RPerl/Grammar.pm
9083             ],
9084             [#Rule VariableDeclaration_195
9085             'VariableDeclaration', 4,
9086             sub {
9087             #line 24 "lib/RPerl/Grammar.eyp"
9088              
9089             my $self = shift;
9090             my $name = $self->YYName();
9091             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9092             }
9093             #line 9093 lib/RPerl/Grammar.pm
9094             ],
9095             [#Rule VariableDeclaration_196
9096             'VariableDeclaration', 5,
9097             sub {
9098             #line 24 "lib/RPerl/Grammar.eyp"
9099              
9100             my $self = shift;
9101             my $name = $self->YYName();
9102             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9103             }
9104             #line 9104 lib/RPerl/Grammar.pm
9105             ],
9106             [#Rule VariableDeclaration_197
9107             'VariableDeclaration', 9,
9108             sub {
9109             #line 24 "lib/RPerl/Grammar.eyp"
9110              
9111             my $self = shift;
9112             my $name = $self->YYName();
9113             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9114             }
9115             #line 9115 lib/RPerl/Grammar.pm
9116             ],
9117             [#Rule VariableDeclaration_198
9118             'VariableDeclaration', 4,
9119             sub {
9120             #line 24 "lib/RPerl/Grammar.eyp"
9121              
9122             my $self = shift;
9123             my $name = $self->YYName();
9124             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9125             }
9126             #line 9126 lib/RPerl/Grammar.pm
9127             ],
9128             [#Rule VariableModification_199
9129             'VariableModification', 3,
9130             sub {
9131             #line 24 "lib/RPerl/Grammar.eyp"
9132              
9133             my $self = shift;
9134             my $name = $self->YYName();
9135             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9136             }
9137             #line 9137 lib/RPerl/Grammar.pm
9138             ],
9139             [#Rule VariableModification_200
9140             'VariableModification', 3,
9141             sub {
9142             #line 24 "lib/RPerl/Grammar.eyp"
9143              
9144             my $self = shift;
9145             my $name = $self->YYName();
9146             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9147             }
9148             #line 9148 lib/RPerl/Grammar.pm
9149             ],
9150             [#Rule _PAREN
9151             'PAREN-51', 2,
9152             sub {
9153             #line 257 "lib/RPerl/Grammar.eyp"
9154             goto &Parse::Eyapp::Driver::YYActionforParenthesis}
9155             #line 9155 lib/RPerl/Grammar.pm
9156             ],
9157             [#Rule _STAR_LIST
9158             'STAR-52', 2,
9159             sub {
9160             #line 257 "lib/RPerl/Grammar.eyp"
9161             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
9162             #line 9162 lib/RPerl/Grammar.pm
9163             ],
9164             [#Rule _STAR_LIST
9165             'STAR-52', 0,
9166             sub {
9167             #line 257 "lib/RPerl/Grammar.eyp"
9168             goto &Parse::Eyapp::Driver::YYActionforT_empty }
9169             #line 9169 lib/RPerl/Grammar.pm
9170             ],
9171             [#Rule ListElements_204
9172             'ListElements', 2,
9173             sub {
9174             #line 24 "lib/RPerl/Grammar.eyp"
9175              
9176             my $self = shift;
9177             my $name = $self->YYName();
9178             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9179             }
9180             #line 9180 lib/RPerl/Grammar.pm
9181             ],
9182             [#Rule ListElement_205
9183             'ListElement', 1,
9184             sub {
9185             #line 24 "lib/RPerl/Grammar.eyp"
9186              
9187             my $self = shift;
9188             my $name = $self->YYName();
9189             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9190             }
9191             #line 9191 lib/RPerl/Grammar.pm
9192             ],
9193             [#Rule ListElement_206
9194             'ListElement', 2,
9195             sub {
9196             #line 24 "lib/RPerl/Grammar.eyp"
9197              
9198             my $self = shift;
9199             my $name = $self->YYName();
9200             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9201             }
9202             #line 9202 lib/RPerl/Grammar.pm
9203             ],
9204             [#Rule ListElement_207
9205             'ListElement', 1,
9206             sub {
9207             #line 24 "lib/RPerl/Grammar.eyp"
9208              
9209             my $self = shift;
9210             my $name = $self->YYName();
9211             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9212             }
9213             #line 9213 lib/RPerl/Grammar.pm
9214             ],
9215             [#Rule ListElement_208
9216             'ListElement', 1,
9217             sub {
9218             #line 24 "lib/RPerl/Grammar.eyp"
9219              
9220             my $self = shift;
9221             my $name = $self->YYName();
9222             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9223             }
9224             #line 9224 lib/RPerl/Grammar.pm
9225             ],
9226             [#Rule _OPTIONAL
9227             'OPTIONAL-53', 1,
9228             sub {
9229             #line 259 "lib/RPerl/Grammar.eyp"
9230             goto &Parse::Eyapp::Driver::YYActionforT_single }
9231             #line 9231 lib/RPerl/Grammar.pm
9232             ],
9233             [#Rule _OPTIONAL
9234             'OPTIONAL-53', 0,
9235             sub {
9236             #line 259 "lib/RPerl/Grammar.eyp"
9237             goto &Parse::Eyapp::Driver::YYActionforT_empty }
9238             #line 9238 lib/RPerl/Grammar.pm
9239             ],
9240             [#Rule ArrayReference_211
9241             'ArrayReference', 3,
9242             sub {
9243             #line 24 "lib/RPerl/Grammar.eyp"
9244              
9245             my $self = shift;
9246             my $name = $self->YYName();
9247             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9248             }
9249             #line 9249 lib/RPerl/Grammar.pm
9250             ],
9251             [#Rule _OPTIONAL
9252             'OPTIONAL-54', 1,
9253             sub {
9254             #line 260 "lib/RPerl/Grammar.eyp"
9255             goto &Parse::Eyapp::Driver::YYActionforT_single }
9256             #line 9256 lib/RPerl/Grammar.pm
9257             ],
9258             [#Rule _OPTIONAL
9259             'OPTIONAL-54', 0,
9260             sub {
9261             #line 260 "lib/RPerl/Grammar.eyp"
9262             goto &Parse::Eyapp::Driver::YYActionforT_empty }
9263             #line 9263 lib/RPerl/Grammar.pm
9264             ],
9265             [#Rule ArrayDereference_214
9266             'ArrayDereference', 3,
9267             sub {
9268             #line 24 "lib/RPerl/Grammar.eyp"
9269              
9270             my $self = shift;
9271             my $name = $self->YYName();
9272             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9273             }
9274             #line 9274 lib/RPerl/Grammar.pm
9275             ],
9276             [#Rule ArrayDereference_215
9277             'ArrayDereference', 4,
9278             sub {
9279             #line 24 "lib/RPerl/Grammar.eyp"
9280              
9281             my $self = shift;
9282             my $name = $self->YYName();
9283             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9284             }
9285             #line 9285 lib/RPerl/Grammar.pm
9286             ],
9287             [#Rule _OPTIONAL
9288             'OPTIONAL-55', 1,
9289             sub {
9290             #line 261 "lib/RPerl/Grammar.eyp"
9291             goto &Parse::Eyapp::Driver::YYActionforT_single }
9292             #line 9292 lib/RPerl/Grammar.pm
9293             ],
9294             [#Rule _OPTIONAL
9295             'OPTIONAL-55', 0,
9296             sub {
9297             #line 261 "lib/RPerl/Grammar.eyp"
9298             goto &Parse::Eyapp::Driver::YYActionforT_empty }
9299             #line 9299 lib/RPerl/Grammar.pm
9300             ],
9301             [#Rule HashEntry_218
9302             'HashEntry', 4,
9303             sub {
9304             #line 24 "lib/RPerl/Grammar.eyp"
9305              
9306             my $self = shift;
9307             my $name = $self->YYName();
9308             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9309             }
9310             #line 9310 lib/RPerl/Grammar.pm
9311             ],
9312             [#Rule HashEntry_219
9313             'HashEntry', 1,
9314             sub {
9315             #line 24 "lib/RPerl/Grammar.eyp"
9316              
9317             my $self = shift;
9318             my $name = $self->YYName();
9319             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9320             }
9321             #line 9321 lib/RPerl/Grammar.pm
9322             ],
9323             [#Rule HashEntry_220
9324             'HashEntry', 1,
9325             sub {
9326             #line 24 "lib/RPerl/Grammar.eyp"
9327              
9328             my $self = shift;
9329             my $name = $self->YYName();
9330             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9331             }
9332             #line 9332 lib/RPerl/Grammar.pm
9333             ],
9334             [#Rule HashEntryProperties_221
9335             'HashEntryProperties', 3,
9336             sub {
9337             #line 24 "lib/RPerl/Grammar.eyp"
9338              
9339             my $self = shift;
9340             my $name = $self->YYName();
9341             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9342             }
9343             #line 9343 lib/RPerl/Grammar.pm
9344             ],
9345             [#Rule _PAREN
9346             'PAREN-56', 2,
9347             sub {
9348             #line 263 "lib/RPerl/Grammar.eyp"
9349             goto &Parse::Eyapp::Driver::YYActionforParenthesis}
9350             #line 9350 lib/RPerl/Grammar.pm
9351             ],
9352             [#Rule _STAR_LIST
9353             'STAR-57', 2,
9354             sub {
9355             #line 263 "lib/RPerl/Grammar.eyp"
9356             goto &Parse::Eyapp::Driver::YYActionforT_TX1X2 }
9357             #line 9357 lib/RPerl/Grammar.pm
9358             ],
9359             [#Rule _STAR_LIST
9360             'STAR-57', 0,
9361             sub {
9362             #line 263 "lib/RPerl/Grammar.eyp"
9363             goto &Parse::Eyapp::Driver::YYActionforT_empty }
9364             #line 9364 lib/RPerl/Grammar.pm
9365             ],
9366             [#Rule HashReference_225
9367             'HashReference', 4,
9368             sub {
9369             #line 24 "lib/RPerl/Grammar.eyp"
9370              
9371             my $self = shift;
9372             my $name = $self->YYName();
9373             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9374             }
9375             #line 9375 lib/RPerl/Grammar.pm
9376             ],
9377             [#Rule HashReference_226
9378             'HashReference', 2,
9379             sub {
9380             #line 24 "lib/RPerl/Grammar.eyp"
9381              
9382             my $self = shift;
9383             my $name = $self->YYName();
9384             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9385             }
9386             #line 9386 lib/RPerl/Grammar.pm
9387             ],
9388             [#Rule _OPTIONAL
9389             'OPTIONAL-58', 1,
9390             sub {
9391             #line 264 "lib/RPerl/Grammar.eyp"
9392             goto &Parse::Eyapp::Driver::YYActionforT_single }
9393             #line 9393 lib/RPerl/Grammar.pm
9394             ],
9395             [#Rule _OPTIONAL
9396             'OPTIONAL-58', 0,
9397             sub {
9398             #line 264 "lib/RPerl/Grammar.eyp"
9399             goto &Parse::Eyapp::Driver::YYActionforT_empty }
9400             #line 9400 lib/RPerl/Grammar.pm
9401             ],
9402             [#Rule HashDereference_229
9403             'HashDereference', 3,
9404             sub {
9405             #line 24 "lib/RPerl/Grammar.eyp"
9406              
9407             my $self = shift;
9408             my $name = $self->YYName();
9409             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9410             }
9411             #line 9411 lib/RPerl/Grammar.pm
9412             ],
9413             [#Rule HashDereference_230
9414             'HashDereference', 4,
9415             sub {
9416             #line 24 "lib/RPerl/Grammar.eyp"
9417              
9418             my $self = shift;
9419             my $name = $self->YYName();
9420             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9421             }
9422             #line 9422 lib/RPerl/Grammar.pm
9423             ],
9424             [#Rule WordScoped_231
9425             'WordScoped', 1,
9426             sub {
9427             #line 24 "lib/RPerl/Grammar.eyp"
9428              
9429             my $self = shift;
9430             my $name = $self->YYName();
9431             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9432             }
9433             #line 9433 lib/RPerl/Grammar.pm
9434             ],
9435             [#Rule WordScoped_232
9436             'WordScoped', 1,
9437             sub {
9438             #line 24 "lib/RPerl/Grammar.eyp"
9439              
9440             my $self = shift;
9441             my $name = $self->YYName();
9442             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9443             }
9444             #line 9444 lib/RPerl/Grammar.pm
9445             ],
9446             [#Rule LoopLabel_233
9447             'LoopLabel', 1,
9448             sub {
9449             #line 24 "lib/RPerl/Grammar.eyp"
9450              
9451             my $self = shift;
9452             my $name = $self->YYName();
9453             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9454             }
9455             #line 9455 lib/RPerl/Grammar.pm
9456             ],
9457             [#Rule Type_234
9458             'Type', 1,
9459             sub {
9460             #line 24 "lib/RPerl/Grammar.eyp"
9461              
9462             my $self = shift;
9463             my $name = $self->YYName();
9464             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9465             }
9466             #line 9466 lib/RPerl/Grammar.pm
9467             ],
9468             [#Rule Type_235
9469             'Type', 1,
9470             sub {
9471             #line 24 "lib/RPerl/Grammar.eyp"
9472              
9473             my $self = shift;
9474             my $name = $self->YYName();
9475             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9476             }
9477             #line 9477 lib/RPerl/Grammar.pm
9478             ],
9479             [#Rule Type_236
9480             'Type', 1,
9481             sub {
9482             #line 24 "lib/RPerl/Grammar.eyp"
9483              
9484             my $self = shift;
9485             my $name = $self->YYName();
9486             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9487             }
9488             #line 9488 lib/RPerl/Grammar.pm
9489             ],
9490             [#Rule TypeInner_237
9491             'TypeInner', 5,
9492             sub {
9493             #line 24 "lib/RPerl/Grammar.eyp"
9494              
9495             my $self = shift;
9496             my $name = $self->YYName();
9497             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9498             }
9499             #line 9499 lib/RPerl/Grammar.pm
9500             ],
9501             [#Rule TypeInnerProperties_238
9502             'TypeInnerProperties', 6,
9503             sub {
9504             #line 24 "lib/RPerl/Grammar.eyp"
9505              
9506             my $self = shift;
9507             my $name = $self->YYName();
9508             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9509             }
9510             #line 9510 lib/RPerl/Grammar.pm
9511             ],
9512             [#Rule TypeInnerProperties_239
9513             'TypeInnerProperties', 9,
9514             sub {
9515             #line 24 "lib/RPerl/Grammar.eyp"
9516              
9517             my $self = shift;
9518             my $name = $self->YYName();
9519             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9520             }
9521             #line 9521 lib/RPerl/Grammar.pm
9522             ],
9523             [#Rule TypeInnerConstant_240
9524             'TypeInnerConstant', 5,
9525             sub {
9526             #line 24 "lib/RPerl/Grammar.eyp"
9527              
9528             my $self = shift;
9529             my $name = $self->YYName();
9530             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9531             }
9532             #line 9532 lib/RPerl/Grammar.pm
9533             ],
9534             [#Rule VariableOrLiteral_241
9535             'VariableOrLiteral', 1,
9536             sub {
9537             #line 24 "lib/RPerl/Grammar.eyp"
9538              
9539             my $self = shift;
9540             my $name = $self->YYName();
9541             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9542             }
9543             #line 9543 lib/RPerl/Grammar.pm
9544             ],
9545             [#Rule VariableOrLiteral_242
9546             'VariableOrLiteral', 1,
9547             sub {
9548             #line 24 "lib/RPerl/Grammar.eyp"
9549              
9550             my $self = shift;
9551             my $name = $self->YYName();
9552             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9553             }
9554             #line 9554 lib/RPerl/Grammar.pm
9555             ],
9556             [#Rule VarOrLitOrOpStrOrWord_243
9557             'VarOrLitOrOpStrOrWord', 1,
9558             sub {
9559             #line 24 "lib/RPerl/Grammar.eyp"
9560              
9561             my $self = shift;
9562             my $name = $self->YYName();
9563             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9564             }
9565             #line 9565 lib/RPerl/Grammar.pm
9566             ],
9567             [#Rule VarOrLitOrOpStrOrWord_244
9568             'VarOrLitOrOpStrOrWord', 1,
9569             sub {
9570             #line 24 "lib/RPerl/Grammar.eyp"
9571              
9572             my $self = shift;
9573             my $name = $self->YYName();
9574             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9575             }
9576             #line 9576 lib/RPerl/Grammar.pm
9577             ],
9578             [#Rule VarOrLitOrOpStrOrWord_245
9579             'VarOrLitOrOpStrOrWord', 1,
9580             sub {
9581             #line 24 "lib/RPerl/Grammar.eyp"
9582              
9583             my $self = shift;
9584             my $name = $self->YYName();
9585             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9586             }
9587             #line 9587 lib/RPerl/Grammar.pm
9588             ],
9589             [#Rule VariableSymbolOrSelf_246
9590             'VariableSymbolOrSelf', 1,
9591             sub {
9592             #line 24 "lib/RPerl/Grammar.eyp"
9593              
9594             my $self = shift;
9595             my $name = $self->YYName();
9596             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9597             }
9598             #line 9598 lib/RPerl/Grammar.pm
9599             ],
9600             [#Rule VariableSymbolOrSelf_247
9601             'VariableSymbolOrSelf', 1,
9602             sub {
9603             #line 24 "lib/RPerl/Grammar.eyp"
9604              
9605             my $self = shift;
9606             my $name = $self->YYName();
9607             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9608             }
9609             #line 9609 lib/RPerl/Grammar.pm
9610             ],
9611             [#Rule Literal_248
9612             'Literal', 1,
9613             sub {
9614             #line 24 "lib/RPerl/Grammar.eyp"
9615              
9616             my $self = shift;
9617             my $name = $self->YYName();
9618             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9619             }
9620             #line 9620 lib/RPerl/Grammar.pm
9621             ],
9622             [#Rule Literal_249
9623             'Literal', 1,
9624             sub {
9625             #line 24 "lib/RPerl/Grammar.eyp"
9626              
9627             my $self = shift;
9628             my $name = $self->YYName();
9629             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9630             }
9631             #line 9631 lib/RPerl/Grammar.pm
9632             ],
9633             [#Rule OpNamedScolonOrSubExp_250
9634             'OpNamedScolonOrSubExp', 1,
9635             sub {
9636             #line 24 "lib/RPerl/Grammar.eyp"
9637              
9638             my $self = shift;
9639             my $name = $self->YYName();
9640             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9641             }
9642             #line 9642 lib/RPerl/Grammar.pm
9643             ],
9644             [#Rule OpNamedScolonOrSubExp_251
9645             'OpNamedScolonOrSubExp', 1,
9646             sub {
9647             #line 24 "lib/RPerl/Grammar.eyp"
9648              
9649             my $self = shift;
9650             my $name = $self->YYName();
9651             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9652             }
9653             #line 9653 lib/RPerl/Grammar.pm
9654             ],
9655             [#Rule OpNamedScolonOrSubExp_252
9656             'OpNamedScolonOrSubExp', 2,
9657             sub {
9658             #line 24 "lib/RPerl/Grammar.eyp"
9659              
9660             my $self = shift;
9661             my $name = $self->YYName();
9662             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9663             }
9664             #line 9664 lib/RPerl/Grammar.pm
9665             ],
9666             [#Rule OpNamedScolonOrSubExpIn_253
9667             'OpNamedScolonOrSubExpIn', 1,
9668             sub {
9669             #line 24 "lib/RPerl/Grammar.eyp"
9670              
9671             my $self = shift;
9672             my $name = $self->YYName();
9673             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9674             }
9675             #line 9675 lib/RPerl/Grammar.pm
9676             ],
9677             [#Rule OpNamedScolonOrSubExpIn_254
9678             'OpNamedScolonOrSubExpIn', 1,
9679             sub {
9680             #line 24 "lib/RPerl/Grammar.eyp"
9681              
9682             my $self = shift;
9683             my $name = $self->YYName();
9684             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9685             }
9686             #line 9686 lib/RPerl/Grammar.pm
9687             ],
9688             [#Rule OpNamedScolonOrSubExpIn_255
9689             'OpNamedScolonOrSubExpIn', 2,
9690             sub {
9691             #line 24 "lib/RPerl/Grammar.eyp"
9692              
9693             my $self = shift;
9694             my $name = $self->YYName();
9695             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9696             }
9697             #line 9697 lib/RPerl/Grammar.pm
9698             ],
9699             [#Rule OpStringOrWord_256
9700             'OpStringOrWord', 1,
9701             sub {
9702             #line 24 "lib/RPerl/Grammar.eyp"
9703              
9704             my $self = shift;
9705             my $name = $self->YYName();
9706             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9707             }
9708             #line 9708 lib/RPerl/Grammar.pm
9709             ],
9710             [#Rule OpStringOrWord_257
9711             'OpStringOrWord', 1,
9712             sub {
9713             #line 24 "lib/RPerl/Grammar.eyp"
9714              
9715             my $self = shift;
9716             my $name = $self->YYName();
9717             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9718             }
9719             #line 9719 lib/RPerl/Grammar.pm
9720             ],
9721             [#Rule OpStringOrWord_258
9722             'OpStringOrWord', 1,
9723             sub {
9724             #line 24 "lib/RPerl/Grammar.eyp"
9725              
9726             my $self = shift;
9727             my $name = $self->YYName();
9728             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9729             }
9730             #line 9730 lib/RPerl/Grammar.pm
9731             ],
9732             [#Rule OpStringOrWord_259
9733             'OpStringOrWord', 1,
9734             sub {
9735             #line 24 "lib/RPerl/Grammar.eyp"
9736              
9737             my $self = shift;
9738             my $name = $self->YYName();
9739             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9740             }
9741             #line 9741 lib/RPerl/Grammar.pm
9742             ],
9743             [#Rule OpStringOrWord_260
9744             'OpStringOrWord', 1,
9745             sub {
9746             #line 24 "lib/RPerl/Grammar.eyp"
9747              
9748             my $self = shift;
9749             my $name = $self->YYName();
9750             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9751             }
9752             #line 9752 lib/RPerl/Grammar.pm
9753             ],
9754             [#Rule OpStringOrWord_261
9755             'OpStringOrWord', 1,
9756             sub {
9757             #line 24 "lib/RPerl/Grammar.eyp"
9758              
9759             my $self = shift;
9760             my $name = $self->YYName();
9761             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9762             }
9763             #line 9763 lib/RPerl/Grammar.pm
9764             ],
9765             [#Rule OpStringOrWord_262
9766             'OpStringOrWord', 1,
9767             sub {
9768             #line 24 "lib/RPerl/Grammar.eyp"
9769              
9770             my $self = shift;
9771             my $name = $self->YYName();
9772             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9773             }
9774             #line 9774 lib/RPerl/Grammar.pm
9775             ],
9776             [#Rule OpStringOrWord_263
9777             'OpStringOrWord', 1,
9778             sub {
9779             #line 24 "lib/RPerl/Grammar.eyp"
9780              
9781             my $self = shift;
9782             my $name = $self->YYName();
9783             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9784             }
9785             #line 9785 lib/RPerl/Grammar.pm
9786             ],
9787             [#Rule OpStringOrWord_264
9788             'OpStringOrWord', 1,
9789             sub {
9790             #line 24 "lib/RPerl/Grammar.eyp"
9791              
9792             my $self = shift;
9793             my $name = $self->YYName();
9794             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9795             }
9796             #line 9796 lib/RPerl/Grammar.pm
9797             ],
9798             [#Rule OpStringOrWord_265
9799             'OpStringOrWord', 1,
9800             sub {
9801             #line 24 "lib/RPerl/Grammar.eyp"
9802              
9803             my $self = shift;
9804             my $name = $self->YYName();
9805             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9806             }
9807             #line 9807 lib/RPerl/Grammar.pm
9808             ],
9809             [#Rule OpStringOrWord_266
9810             'OpStringOrWord', 1,
9811             sub {
9812             #line 24 "lib/RPerl/Grammar.eyp"
9813              
9814             my $self = shift;
9815             my $name = $self->YYName();
9816             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9817             }
9818             #line 9818 lib/RPerl/Grammar.pm
9819             ],
9820             [#Rule OpStringOrWord_267
9821             'OpStringOrWord', 1,
9822             sub {
9823             #line 24 "lib/RPerl/Grammar.eyp"
9824              
9825             my $self = shift;
9826             my $name = $self->YYName();
9827             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9828             }
9829             #line 9829 lib/RPerl/Grammar.pm
9830             ],
9831             [#Rule OpStringOrWord_268
9832             'OpStringOrWord', 1,
9833             sub {
9834             #line 24 "lib/RPerl/Grammar.eyp"
9835              
9836             my $self = shift;
9837             my $name = $self->YYName();
9838             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9839             }
9840             #line 9840 lib/RPerl/Grammar.pm
9841             ],
9842             [#Rule OpStringOrWord_269
9843             'OpStringOrWord', 1,
9844             sub {
9845             #line 24 "lib/RPerl/Grammar.eyp"
9846              
9847             my $self = shift;
9848             my $name = $self->YYName();
9849             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9850             }
9851             #line 9851 lib/RPerl/Grammar.pm
9852             ],
9853             [#Rule OpStringOrWord_270
9854             'OpStringOrWord', 1,
9855             sub {
9856             #line 24 "lib/RPerl/Grammar.eyp"
9857              
9858             my $self = shift;
9859             my $name = $self->YYName();
9860             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9861             }
9862             #line 9862 lib/RPerl/Grammar.pm
9863             ],
9864             [#Rule OpStringOrWord_271
9865             'OpStringOrWord', 1,
9866             sub {
9867             #line 24 "lib/RPerl/Grammar.eyp"
9868              
9869             my $self = shift;
9870             my $name = $self->YYName();
9871             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9872             }
9873             #line 9873 lib/RPerl/Grammar.pm
9874             ],
9875             [#Rule OpStringOrWord_272
9876             'OpStringOrWord', 1,
9877             sub {
9878             #line 24 "lib/RPerl/Grammar.eyp"
9879              
9880             my $self = shift;
9881             my $name = $self->YYName();
9882             bless { children => [ @_ ], line_number => ($self->{TOKENLINE} + 1) }, $name;
9883             }
9884 1744         6438028 #line 9884 lib/RPerl/Grammar.pm
9885             ]
9886             ],
9887             #line 9887 lib/RPerl/Grammar.pm
9888             yybypass => 0,
9889             yybuildingtree => 1,
9890             yyprefix => '',
9891             yyaccessors => {
9892             },
9893             yyconflicthandlers => {}
9894             ,
9895             yystateconflict => { },
9896             @_,
9897 0         0 );
9898             bless($self,$class);
9899 0         0  
9900             $self->make_node_classes('TERMINAL', '_OPTIONAL', '_STAR_LIST', '_PLUS_LIST',
9901             '_SUPERSTART',
9902             '_PAREN',
9903             '_PLUS_LIST',
9904             '_PLUS_LIST',
9905             'CompileUnit_4',
9906             'CompileUnit_5',
9907             '_OPTIONAL',
9908             '_OPTIONAL',
9909             '_STAR_LIST',
9910             '_STAR_LIST',
9911             '_STAR_LIST',
9912             '_STAR_LIST',
9913             '_STAR_LIST',
9914             '_STAR_LIST',
9915             '_STAR_LIST',
9916             '_STAR_LIST',
9917             '_PLUS_LIST',
9918             '_PLUS_LIST',
9919             'Program_18',
9920             '_OPTIONAL',
9921             '_OPTIONAL',
9922             '_OPTIONAL',
9923             '_OPTIONAL',
9924             'ModuleHeader_23',
9925             'Module_24',
9926             'Module_25',
9927             '_STAR_LIST',
9928             '_STAR_LIST',
9929             '_OPTIONAL',
9930             '_OPTIONAL',
9931             '_STAR_LIST',
9932             '_STAR_LIST',
9933             '_STAR_LIST',
9934             '_STAR_LIST',
9935             '_PLUS_LIST',
9936             '_PLUS_LIST',
9937             'Package_36',
9938             '_OPTIONAL',
9939             '_OPTIONAL',
9940             'Header_39',
9941             '_PLUS_LIST',
9942             '_PLUS_LIST',
9943             'Critic_42',
9944             '_PAREN',
9945             '_OPTIONAL',
9946             '_OPTIONAL',
9947             '_PAREN',
9948             '_OPTIONAL',
9949             '_OPTIONAL',
9950             'Exports_49',
9951             'Include_50',
9952             'Include_51',
9953             'Constant_52',
9954             '_OPTIONAL',
9955             '_OPTIONAL',
9956             '_STAR_LIST',
9957             '_STAR_LIST',
9958             'Subroutine_57',
9959             '_PAREN',
9960             '_STAR_LIST',
9961             '_STAR_LIST',
9962             'SubroutineArguments_61',
9963             '_STAR_LIST',
9964             '_STAR_LIST',
9965             '_OPTIONAL',
9966             '_OPTIONAL',
9967             '_STAR_LIST',
9968             '_STAR_LIST',
9969             '_STAR_LIST',
9970             '_STAR_LIST',
9971             '_STAR_LIST',
9972             '_STAR_LIST',
9973             'Class_72',
9974             '_PAREN',
9975             '_STAR_LIST',
9976             '_STAR_LIST',
9977             'Properties_76',
9978             'Properties_77',
9979             '_OPTIONAL',
9980             '_OPTIONAL',
9981             '_STAR_LIST',
9982             '_STAR_LIST',
9983             'Method_82',
9984             '_PAREN',
9985             '_STAR_LIST',
9986             '_STAR_LIST',
9987             'MethodArguments_86',
9988             'SubroutineOrMethod_87',
9989             'SubroutineOrMethod_88',
9990             'Operation_89',
9991             'Operation_90',
9992             'Operation_91',
9993             'Operation_92',
9994             'Operator_93',
9995             'Operator_94',
9996             'Operator_95',
9997             'Operator_96',
9998             'Operator_97',
9999             'Operator_98',
10000             'Operator_99',
10001             'Operator_100',
10002             'Operator_101',
10003             'Operator_102',
10004             'Operator_103',
10005             'Operator_104',
10006             'Operator_105',
10007             'Operator_106',
10008             'Operator_107',
10009             'Operator_108',
10010             'Operator_109',
10011             'Operator_110',
10012             'Operator_111',
10013             'Operator_112',
10014             'Operator_113',
10015             'Operator_114',
10016             'Operator_115',
10017             'Operator_116',
10018             'Operator_117',
10019             'Operator_118',
10020             'Operator_119',
10021             'Operator_120',
10022             'Operator_121',
10023             'Operator_122',
10024             'Operator_123',
10025             '_PAREN',
10026             '_OPTIONAL',
10027             '_OPTIONAL',
10028             '_OPTIONAL',
10029             '_OPTIONAL',
10030             'OperatorVoid_129',
10031             'OperatorVoid_130',
10032             'OperatorVoid_131',
10033             'OperatorVoid_132',
10034             'OperatorVoid_133',
10035             'OperatorVoid_134',
10036             'OperatorVoid_135',
10037             'OperatorVoid_136',
10038             '_OPTIONAL',
10039             '_OPTIONAL',
10040             '_OPTIONAL',
10041             '_OPTIONAL',
10042             '_OPTIONAL',
10043             '_OPTIONAL',
10044             'Expression_143',
10045             'Expression_144',
10046             'Expression_145',
10047             'Expression_146',
10048             'Expression_147',
10049             'Expression_148',
10050             'SubExpression_149',
10051             'SubExpression_150',
10052             'SubExpression_151',
10053             'SubExpression_152',
10054             'SubExpression_153',
10055             'SubExpression_154',
10056             'SubExpression_155',
10057             'SubExpression_156',
10058             'SubExpression_157',
10059             'SubExpressionOrInput_158',
10060             'SubExpressionOrInput_159',
10061             'SubExpressionOrInput_160',
10062             'SubExpressionOrVarMod_161',
10063             'SubExpressionOrVarMod_162',
10064             '_PAREN',
10065             '_OPTIONAL',
10066             '_OPTIONAL',
10067             'Statement_166',
10068             'Statement_167',
10069             'Statement_168',
10070             'Statement_169',
10071             'Statement_170',
10072             '_PAREN',
10073             '_STAR_LIST',
10074             '_STAR_LIST',
10075             '_PAREN',
10076             '_OPTIONAL',
10077             '_OPTIONAL',
10078             'Conditional_177',
10079             'Loop_178',
10080             'Loop_179',
10081             'Loop_180',
10082             'LoopFor_181',
10083             'LoopFor_182',
10084             'LoopForEach_183',
10085             'LoopWhile_184',
10086             'LoopWhile_185',
10087             '_PLUS_LIST',
10088             '_PLUS_LIST',
10089             'CodeBlock_188',
10090             '_STAR_LIST',
10091             '_STAR_LIST',
10092             'Variable_191',
10093             'VariableRetrieval_192',
10094             'VariableRetrieval_193',
10095             'VariableRetrieval_194',
10096             'VariableDeclaration_195',
10097             'VariableDeclaration_196',
10098             'VariableDeclaration_197',
10099             'VariableDeclaration_198',
10100             'VariableModification_199',
10101             'VariableModification_200',
10102             '_PAREN',
10103             '_STAR_LIST',
10104             '_STAR_LIST',
10105             'ListElements_204',
10106             'ListElement_205',
10107             'ListElement_206',
10108             'ListElement_207',
10109             'ListElement_208',
10110             '_OPTIONAL',
10111             '_OPTIONAL',
10112             'ArrayReference_211',
10113             '_OPTIONAL',
10114             '_OPTIONAL',
10115             'ArrayDereference_214',
10116             'ArrayDereference_215',
10117             '_OPTIONAL',
10118             '_OPTIONAL',
10119             'HashEntry_218',
10120             'HashEntry_219',
10121             'HashEntry_220',
10122             'HashEntryProperties_221',
10123             '_PAREN',
10124             '_STAR_LIST',
10125             '_STAR_LIST',
10126             'HashReference_225',
10127             'HashReference_226',
10128             '_OPTIONAL',
10129             '_OPTIONAL',
10130             'HashDereference_229',
10131             'HashDereference_230',
10132             'WordScoped_231',
10133             'WordScoped_232',
10134             'LoopLabel_233',
10135             'Type_234',
10136             'Type_235',
10137             'Type_236',
10138             'TypeInner_237',
10139             'TypeInnerProperties_238',
10140             'TypeInnerProperties_239',
10141             'TypeInnerConstant_240',
10142             'VariableOrLiteral_241',
10143             'VariableOrLiteral_242',
10144             'VarOrLitOrOpStrOrWord_243',
10145             'VarOrLitOrOpStrOrWord_244',
10146             'VarOrLitOrOpStrOrWord_245',
10147             'VariableSymbolOrSelf_246',
10148             'VariableSymbolOrSelf_247',
10149             'Literal_248',
10150             'Literal_249',
10151             'OpNamedScolonOrSubExp_250',
10152             'OpNamedScolonOrSubExp_251',
10153             'OpNamedScolonOrSubExp_252',
10154             'OpNamedScolonOrSubExpIn_253',
10155             'OpNamedScolonOrSubExpIn_254',
10156             'OpNamedScolonOrSubExpIn_255',
10157             'OpStringOrWord_256',
10158             'OpStringOrWord_257',
10159             'OpStringOrWord_258',
10160             'OpStringOrWord_259',
10161             'OpStringOrWord_260',
10162             'OpStringOrWord_261',
10163             'OpStringOrWord_262',
10164             'OpStringOrWord_263',
10165             'OpStringOrWord_264',
10166             'OpStringOrWord_265',
10167             'OpStringOrWord_266',
10168             'OpStringOrWord_267',
10169             'OpStringOrWord_268',
10170             'OpStringOrWord_269',
10171             'OpStringOrWord_270',
10172             'OpStringOrWord_271',
10173 0         0 'OpStringOrWord_272', );
10174             $self;
10175             }
10176              
10177             #line 285 "lib/RPerl/Grammar.eyp"
10178              
10179              
10180             # [[[ SEMANTIC MAP, ABSTRACT SYNTAX TREE NODES TO CLASSES ]]]
10181              
10182             {
10183             # Map from abstract syntax tree to classes
10184             # DEV NOTE: derived from grammar rules in Grammar.output file, use the following process for grammar updates...
10185             # 1. Update grammar code in this file, above this line only
10186             # 2. Run `script/development/grammar_recompile.sh`
10187             # 3. Run `perl t/12_parse.t` for new & existing grammar parse-only tests, if errors goto step 1
10188             # 4. Inspect updates from Grammar.output file, note starting & finishing & increment/decrement numbers if any rule numbers have changed
10189             # 5a. Run `script/development/grammar_increment.pl START FINISH INCREMENT` if rules added from step 4, repeat if needed
10190             # 5b. Run `script/development/grammar_decrement.pl START FINISH DECREMENT` if rules deleted from step 4, repeat if needed
10191             # 6. Copy updates from Grammar.output file into this file with now-unique numbers, below this line only, if not-automatically-generated rules have been added
10192             # 7. Run `script/development/grammar_recompile.sh` again
10193             our string_hashref $RULES = {
10194             CompileUnit_4 => 'RPerl::CompileUnit::Program', # CompileUnit -> Program
10195             CompileUnit_5 => 'RPerl::CompileUnit::Module', # CompileUnit -> PLUS-2
10196             Program_18 => 'RPerl::CompileUnit::Program', # Program -> SHEBANG OPTIONAL-3 USE_RPERL Header STAR-4 STAR-5 STAR-6 STAR-7 PLUS-8
10197             ModuleHeader_23 => 'RPerl::CompileUnit::Module::Header', # ModuleHeader -> OPTIONAL-9 OPTIONAL-10 'package' WordScoped ';' Header
10198             Module_24 => 'RPerl::CompileUnit::Module::Package', # Module -> Package
10199             Module_25 => 'RPerl::CompileUnit::Module::Class::Generator', # Module -> Class
10200             Package_36 => 'RPerl::CompileUnit::Module::Package', # Package -> STAR-11 OPTIONAL-12 STAR-13 STAR-14 PLUS-15 LITERAL_NUMBER ';'
10201             Header_39 => 'RPerl::NonGenerator', # Header -> 'use strict;' 'use warnings;' OPTIONAL-16 'our' VERSION_NUMBER_ASSIGN
10202             Critic_42 => 'RPerl::CompileUnit::Critic', # Critic -> '## no critic qw(' PLUS-17 ')'
10203             Exports_49 => 'RPerl::NonGenerator', # Exports -> USE_EXPORTER OPTIONAL-19 OPTIONAL-21
10204             Include_50 => 'RPerl::CompileUnit::Include', # Include -> USE WordScoped ';'
10205             Include_51 => 'RPerl::CompileUnit::Include', # Include -> USE WordScoped OP01_QW ';'
10206             Constant_52 => 'RPerl::CompileUnit::Constant', # Constant -> 'use constant' WORD_UPPERCASE OP20_HASH_FATARROW TypeInnerConstant Literal ';'
10207             Subroutine_57 => 'RPerl::CodeBlock::Subroutine', # Subroutine -> SUB WORD LBRACE LBRACE MY Type '$RETURN_TYPE' '}' ';' OPTIONAL-22 STAR-23 '}'
10208             SubroutineArguments_61 => 'RPerl::CodeBlock::Subroutine::Arguments', # SubroutineArguments -> LPAREN_MY Type VARIABLE_SYMBOL STAR-25 ')' OP19_VARIABLE_ASSIGN '@ARG;'
10209             Class_72 => 'RPerl::CompileUnit::Module::Class::Generator', # Class -> 'use parent qw(' WordScoped ')' ';' Include STAR-26 OPTIONAL-27 STAR-28 STAR-29 Properties STAR-30 LITERAL_NUMBER ';'
10210             Properties_76 => 'RPerl::NonGenerator', # Properties -> 'our hashref $properties' OP19_VARIABLE_ASSIGN LBRACE HashEntryProperties STAR-32 '}' ';'
10211             Properties_77 => 'RPerl::NonGenerator', # Properties -> 'our hashref $properties' OP19_VARIABLE_ASSIGN LBRACE '}' ';'
10212             Method_82 => 'RPerl::CodeBlock::Subroutine::Method', # Method -> SUB WORD LBRACE LBRACE MY TYPE_METHOD '$RETURN_TYPE' '}' ';' OPTIONAL-33 STAR-34 '}'
10213             MethodArguments_86 => 'RPerl::CodeBlock::Subroutine::Method::Arguments', # MethodArguments -> LPAREN_MY Type SELF STAR-36 ')' OP19_VARIABLE_ASSIGN '@ARG;'
10214             SubroutineOrMethod_87 => 'RPerl::CodeBlock::Subroutine', # SubroutineOrMethod -> Subroutine
10215             SubroutineOrMethod_88 => 'RPerl::CodeBlock::Subroutine::Method', # SubroutineOrMethod -> Method
10216             Operation_89 => 'RPerl::Operation::Expression', # Operation -> Expression ';'
10217             Operation_90 => 'RPerl::Operation::Expression::Operator::Named', # Operation -> OP01_NAMED_SCOLON
10218             Operation_91 => 'RPerl::Operation::Expression::Operator::NamedUnary', # Operation -> OP10_NAMED_UNARY_SCOLON
10219             Operation_92 => 'RPerl::Operation::Statement', # Operation -> Statement
10220             Operator_93 => 'RPerl::Operation::Expression::Operator::Print', # Operator -> LPAREN OP01_PRINT FHREF_SYMBOL_BRACES ListElements ')'
10221             Operator_94 => 'RPerl::Operation::Expression::Operator::Named', # Operator -> OP01_NAMED SubExpression
10222             Operator_95 => 'RPerl::Operation::Expression::Operator::Named', # Operator -> LPAREN OP01_NAMED ListElement OP21_LIST_COMMA ListElements ')'
10223             Operator_96 => 'RPerl::Operation::Expression::Operator::Open', # Operator -> OP01_OPEN MY TYPE_FHREF FHREF_SYMBOL OP21_LIST_COMMA LITERAL_STRING OP21_LIST_COMMA SubExpression
10224             Operator_97 => 'RPerl::Operation::Expression::Operator::Close', # Operator -> OP01_CLOSE FHREF_SYMBOL
10225             Operator_98 => 'RPerl::Operation::Expression::Operator::IncrementDecrement', # Operator -> OP03_MATH_INC_DEC Variable
10226             Operator_99 => 'RPerl::Operation::Expression::Operator::IncrementDecrement', # Operator -> Variable OP03_MATH_INC_DEC
10227             Operator_100 => 'RPerl::Operation::Expression::Operator::Arithmetic::Power', # Operator -> SubExpression OP04_MATH_POW SubExpression
10228             Operator_101 => 'RPerl::Operation::Expression::Operator::Bitwise::Negation', # Operator -> OP05_BITWISE_NEG_LPAREN SubExpression ')'
10229             Operator_102 => 'RPerl::Operation::Expression::Operator::Logical::Negation', # Operator -> OP05_LOGICAL_NEG SubExpression
10230             Operator_103 => 'RPerl::Operation::Expression::Operator::Arithmetic::Negative', # Operator -> OP05_MATH_NEG_LPAREN SubExpression ')'
10231             Operator_104 => 'RPerl::Operation::Expression::Operator::RegularExpression', # Operator -> SubExpression OP06_REGEX_BIND OP06_REGEX_PATTERN
10232             Operator_105 => 'RPerl::Operation::Expression::Operator::String::Repeat', # Operator -> SubExpression OP07_STRING_REPEAT SubExpression
10233             Operator_106 => 'RPerl::Operation::Expression::Operator::Arithmetic::MultiplyDivideModulo', # Operator -> SubExpression OP07_MATH_MULT_DIV_MOD SubExpression
10234             Operator_107 => 'RPerl::Operation::Expression::Operator::Arithmetic::AddSubtract', # Operator -> SubExpression OP08_MATH_ADD_SUB SubExpression
10235             Operator_108 => 'RPerl::Operation::Expression::Operator::String::Concatenate', # Operator -> SubExpression OP08_STRING_CAT SubExpression
10236             Operator_109 => 'RPerl::Operation::Expression::Operator::Bitwise::Shift', # Operator -> SubExpression OP09_BITWISE_SHIFT SubExpression
10237             Operator_110 => 'RPerl::Operation::Expression::Operator::NamedUnary', # Operator -> OP10_NAMED_UNARY SubExpression
10238             Operator_111 => 'RPerl::Operation::Expression::Operator::NamedUnary', # Operator -> OP10_NAMED_UNARY
10239             Operator_112 => 'RPerl::Operation::Expression::Operator::Compare::LessThanGreaterThan', # Operator -> SubExpression OP11_COMPARE_LT_GT SubExpression
10240             Operator_113 => 'RPerl::Operation::Expression::Operator::Compare::EqualNotEqual', # Operator -> SubExpression OP12_COMPARE_EQ_NE SubExpression
10241             Operator_114 => 'RPerl::Operation::Expression::Operator::Bitwise::And', # Operator -> SubExpression OP13_BITWISE_AND SubExpression
10242             Operator_115 => 'RPerl::Operation::Expression::Operator::Bitwise::OrXor', # Operator -> SubExpression OP14_BITWISE_OR_XOR SubExpression
10243             Operator_116 => 'RPerl::Operation::Expression::Operator::Logical::And', # Operator -> SubExpression OP15_LOGICAL_AND SubExpression
10244             Operator_117 => 'RPerl::Operation::Expression::Operator::Logical::OrXor', # Operator -> SubExpression OP16_LOGICAL_OR SubExpression
10245             Operator_118 => 'RPerl::Operation::Expression::Operator::List::Range', # Operator -> SubExpression OP17_LIST_RANGE SubExpression
10246             Operator_119 => 'RPerl::Operation::Expression::Operator::Ternary', # Operator -> SubExpression OP18_TERNARY VariableOrLiteral COLON VariableOrLiteral
10247             Operator_120 => 'RPerl::Operation::Expression::Operator::Logical::Negation', # Operator -> OP22_LOGICAL_NEG_LPAREN SubExpression ')'
10248             Operator_121 => 'RPerl::Operation::Expression::Operator::Logical::Negation', # Operator -> OP22_LOGICAL_NEG SubExpression
10249             Operator_122 => 'RPerl::Operation::Expression::Operator::Logical::And', # Operator -> SubExpression OP23_LOGICAL_AND SubExpression
10250             Operator_123 => 'RPerl::Operation::Expression::Operator::Logical::OrXor', # Operator -> SubExpression OP24_LOGICAL_OR_XOR SubExpression
10251             OperatorVoid_129 => 'RPerl::Operation::Statement::OperatorVoid::Print', # OperatorVoid -> OP01_PRINT OPTIONAL-31 ListElements ';'
10252             OperatorVoid_130 => 'RPerl::Operation::Statement::OperatorVoid::Print', # OperatorVoid -> OP01_PRINT FHREF_SYMBOL_BRACES ListElements ';'
10253             OperatorVoid_131 => 'RPerl::Operation::Statement::OperatorVoid::Named', # OperatorVoid -> OP01_NAMED_VOID_SCOLON
10254             OperatorVoid_132 => 'RPerl::Operation::Statement::OperatorVoid::Named', # OperatorVoid -> OP01_NAMED_VOID_LPAREN OPTIONAL-32 ')' ';'
10255             OperatorVoid_133 => 'RPerl::Operation::Statement::OperatorVoid::Named', # OperatorVoid -> OP01_NAMED_VOID ListElements ';'
10256             OperatorVoid_134 => 'RPerl::Operation::Expression::Operator::Named', # OperatorVoid -> OP01_NAMED ListElement OP21_LIST_COMMA ListElements ';'
10257             OperatorVoid_135 => 'RPerl::Operation::Statement::OperatorVoid::LoopControl', # OperatorVoid -> OP19_LOOP_CONTROL_SCOLON
10258             OperatorVoid_136 => 'RPerl::Operation::Statement::OperatorVoid::LoopControl', # OperatorVoid -> OP19_LOOP_CONTROL LoopLabel ';'
10259             Expression_143 => 'RPerl::Operation::Expression::Operator', # Expression -> Operator
10260             Expression_144 => 'RPerl::Operation::Expression::ConstantCall', # Expression -> WORD_UPPERCASE LPAREN ')'
10261             Expression_145 => 'RPerl::Operation::Expression::ConstantCall', # Expression -> CONSTANT_CALL_SCOPED
10262             Expression_146 => 'RPerl::Operation::Expression::SubroutineCall', # Expression -> WordScoped LPAREN OPTIONAL-40 ')'
10263             Expression_147 => 'RPerl::Operation::Expression::SubroutineCall::MethodCall', # Expression -> Variable OP02_METHOD_THINARROW LPAREN OPTIONAL-41 ')'
10264             Expression_148 => 'RPerl::Operation::Expression::SubroutineCall::MethodCall::ConstructorCall', # Expression -> WordScoped OP02_METHOD_THINARROW_NEW OPTIONAL-42 ')'
10265             SubExpression_149 => 'RPerl::Operation::Expression', # SubExpression -> Expression
10266             SubExpression_150 => 'RPerl::Operation::Expression::SubExpression::Literal::Undefined', # SubExpression -> 'undef'
10267             SubExpression_151 => 'RPerl::Operation::Expression::SubExpression::Literal', # SubExpression -> Literal
10268             SubExpression_152 => 'RPerl::Operation::Expression::SubExpression::Variable', # SubExpression -> Variable
10269             SubExpression_153 => 'RPerl::DataStructure::Array::Reference', # SubExpression -> ArrayReference
10270             SubExpression_154 => 'RPerl::Operation::Expression::SubExpression::ArrayDereference', # SubExpression -> ArrayDereference
10271             SubExpression_155 => 'RPerl::DataStructure::Hash::Reference', # SubExpression -> HashReference
10272             SubExpression_156 => 'RPerl::Operation::Expression::SubExpression::HashDereference', # SubExpression -> HashDereference
10273             SubExpression_157 => 'RPerl::Operation::Expression::SubExpression::Parenthesis', # SubExpression -> LPAREN SubExpression ')'
10274             SubExpressionOrInput_158 => 'RPerl::Operation::Expression::SubExpression', # SubExpressionOrInput -> SubExpression
10275             SubExpressionOrInput_159 => 'RPerl::InputOutput::FilehandleIn', # SubExpressionOrInput -> FHREF_SYMBOL_IN
10276             SubExpressionOrInput_160 => 'RPerl::InputOutput::Stdin', # SubExpressionOrInput -> STDIN
10277             SubExpressionOrVarMod_161 => 'RPerl::Operation::Expression::SubExpression', # SubExpressionOrVarMod -> SubExpression
10278             SubExpressionOrVarMod_162 => 'RPerl::Operation::Statement::VariableModification', # SubExpressionOrVarMod -> VariableModification
10279             Statement_166 => 'RPerl::Operation::Statement::Conditional', # Statement -> Conditional
10280             Statement_167 => 'RPerl::Operation::Statement::Loop', # Statement -> OPTIONAL-44 Loop
10281             Statement_168 => 'RPerl::Operation::Statement::OperatorVoid', # Statement -> OperatorVoid
10282             Statement_169 => 'RPerl::Operation::Statement::VariableDeclaration', # Statement -> VariableDeclaration
10283             Statement_170 => 'RPerl::Operation::Statement::VariableModification', # Statement -> VariableModification ';'
10284             Conditional_177 => 'RPerl::Operation::Statement::Conditional', # Conditional -> 'if' LPAREN SubExpression ')' CodeBlock STAR-46 OPTIONAL-48
10285             Loop_178 => 'RPerl::Operation::Statement::Loop::For', # Loop -> LoopFor
10286             Loop_179 => 'RPerl::Operation::Statement::Loop::ForEach', # Loop -> LoopForEach
10287             Loop_180 => 'RPerl::Operation::Statement::Loop::While', # Loop -> LoopWhile
10288             LoopFor_181 => 'RPerl::Operation::Statement::Loop::For', # LoopFor -> 'for' MY TYPE_INTEGER VARIABLE_SYMBOL LPAREN SubExpression OP17_LIST_RANGE SubExpression ')' CodeBlock
10289             LoopFor_182 => 'RPerl::Operation::Statement::Loop::For', # LoopFor -> 'for' LPAREN_MY TYPE_INTEGER VARIABLE_SYMBOL OP19_VARIABLE_ASSIGN OpNamedScolonOrSubExp VARIABLE_SYMBOL OP11_COMPARE_LT_GT OpNamedScolonOrSubExp SubExpressionOrVarMod ')' CodeBlock
10290             LoopForEach_183 => 'RPerl::Operation::Statement::Loop::ForEach', # LoopForEach -> 'foreach' MY Type VARIABLE_SYMBOL LPAREN ListElements ')' CodeBlock
10291             LoopWhile_184 => 'RPerl::Operation::Statement::Loop::While', # LoopWhile -> 'while' LPAREN SubExpression ')' CodeBlock
10292             LoopWhile_185 => 'RPerl::Operation::Statement::Loop::While', # LoopWhile -> 'while' LPAREN_MY Type VARIABLE_SYMBOL OP19_VARIABLE_ASSIGN SubExpressionOrInput ')' CodeBlock
10293             CodeBlock_188 => 'RPerl::CodeBlock', # CodeBlock -> LBRACE PLUS-49 '}'
10294             Variable_191 => 'RPerl::Operation::Expression::SubExpression::Variable', # Variable -> VariableSymbolOrSelf STAR-50
10295             VariableRetrieval_192 => 'RPerl::Operation::Expression::SubExpression::Variable::Retrieval', # VariableRetrieval -> OP02_ARRAY_THINARROW SubExpression ']'
10296             VariableRetrieval_193 => 'RPerl::Operation::Expression::SubExpression::Variable::Retrieval', # VariableRetrieval -> OP02_HASH_THINARROW SubExpression '}'
10297             VariableRetrieval_194 => 'RPerl::Operation::Expression::SubExpression::Variable::Retrieval', # VariableRetrieval -> OP02_HASH_THINARROW WORD '}'
10298             VariableDeclaration_195 => 'RPerl::Operation::Statement::VariableDeclaration', # VariableDeclaration -> MY Type VARIABLE_SYMBOL ';'
10299             VariableDeclaration_196 => 'RPerl::Operation::Statement::VariableDeclaration', # VariableDeclaration -> MY Type VARIABLE_SYMBOL OP19_VARIABLE_ASSIGN OpNamedScolonOrSubExpIn
10300             VariableDeclaration_197 => 'RPerl::Operation::Statement::VariableDeclaration', # VariableDeclaration -> MY Type VARIABLE_SYMBOL OP02_ARRAY_THINARROW SubExpression ']' OP19_VARIABLE_ASSIGN 'undef' ';'
10301             VariableDeclaration_198 => 'RPerl::Operation::Statement::VariableDeclaration', # VariableDeclaration -> MY TYPE_FHREF FHREF_SYMBOL ';'
10302             VariableModification_199 => 'RPerl::Operation::Statement::VariableModification', # VariableModification -> Variable OP19_VARIABLE_ASSIGN SubExpressionOrInput
10303             VariableModification_200 => 'RPerl::Operation::Statement::VariableModification', # VariableModification -> Variable OP19_VARIABLE_ASSIGN_BY SubExpression
10304             ListElements_204 => 'RPerl::DataStructure::Array::ListElements', # ListElements -> ListElement STAR-52
10305             ListElement_205 => 'RPerl::Operation::Expression::SubExpression', # ListElement -> SubExpression
10306             ListElement_206 => 'RPerl::Operation::Expression::SubExpression', # ListElement -> TypeInner SubExpression
10307             ListElement_207 => 'RPerl::DataStructure::Array::ListElement', # ListElement -> OP01_QW
10308             ListElement_208 => 'RPerl::DataStructure::Array::ListElement', # ListElement -> ARGV
10309             ArrayReference_211 => 'RPerl::DataStructure::Array::Reference', # ArrayReference -> LBRACKET OPTIONAL-53 ']'
10310             ArrayDereference_214 => 'RPerl::Operation::Expression::SubExpression::ArrayDereference', # ArrayDereference -> '@{' Variable '}'
10311             ArrayDereference_215 => 'RPerl::Operation::Expression::SubExpression::ArrayDereference', # ArrayDereference -> '@{' OPTIONAL-54 ArrayReference '}'
10312             HashEntry_218 => 'RPerl::DataStructure::Hash::Entry', # HashEntry -> VarOrLitOrOpStrOrWord OP20_HASH_FATARROW OPTIONAL-55 SubExpression
10313             HashEntry_219 => 'RPerl::Operation::Expression::SubExpression::HashDereference', # HashEntry -> HashDereference
10314             HashEntry_220 => 'RPerl::DataStructure::Hash::Entry', # HashEntry -> ENV
10315             HashEntryProperties_221 => 'RPerl::NonGenerator', # HashEntryProperties -> OpStringOrWord OP20_HASH_FATARROW TypeInnerProperties
10316             HashReference_225 => 'RPerl::DataStructure::Hash::Reference', # HashReference -> LBRACE HashEntry STAR-57 '}'
10317             HashReference_226 => 'RPerl::DataStructure::Hash::Reference', # HashReference -> LBRACE '}'
10318             HashDereference_229 => 'RPerl::Operation::Expression::SubExpression::HashDereference', # HashDereference -> '%{' Variable '}'
10319             HashDereference_230 => 'RPerl::Operation::Expression::SubExpression::HashDereference', # HashDereference -> '%{' OPTIONAL-58 HashReference '}'
10320             WordScoped_231 => 'RPerl::NonGenerator', # WordScoped -> WORD
10321             WordScoped_232 => 'RPerl::NonGenerator', # WordScoped -> WORD_SCOPED
10322             LoopLabel_233 => 'RPerl::NonGenerator', # LoopLabel -> WORD_UPPERCASE # RPerl::Operation::Statement -> LoopLabel COLON
10323             Type_234 => 'RPerl::NonGenerator', # Type -> WORD
10324             Type_235 => 'RPerl::NonGenerator', # Type -> WORD_SCOPED
10325             Type_236 => 'RPerl::NonGenerator', # Type -> TYPE_INTEGER
10326             TypeInner_237 => 'RPerl::DataType::TypeInner', # TypeInner -> MY Type '$TYPED_' OpStringOrWord OP19_VARIABLE_ASSIGN
10327             TypeInnerProperties_238 => 'RPerl::NonGenerator', # TypeInnerProperties -> MY Type '$TYPED_' OpStringOrWord OP19_VARIABLE_ASSIGN SubExpression
10328             TypeInnerProperties_239 => 'RPerl::NonGenerator', # TypeInnerProperties -> MY Type '$TYPED_' OpStringOrWord OP02_ARRAY_THINARROW SubExpression ']' OP19_VARIABLE_ASSIGN 'undef'
10329             TypeInnerConstant_240 => 'RPerl::NonGenerator', # TypeInnerConstant -> MY Type '$TYPED_' WORD_UPPERCASE OP19_VARIABLE_ASSIGN
10330             VariableOrLiteral_241 => 'RPerl::Operation::Expression::SubExpression::Variable', # VariableOrLiteral -> Variable
10331             VariableOrLiteral_242 => 'RPerl::Operation::Expression::SubExpression::Literal', # VariableOrLiteral -> Literal
10332             VarOrLitOrOpStrOrWord_243 => 'RPerl::Operation::Expression::SubExpression::Variable', # VarOrLitOrOpStrOrWord -> Variable
10333             VarOrLitOrOpStrOrWord_244 => 'RPerl::Operation::Expression::SubExpression::Literal', # VarOrLitOrOpStrOrWord -> Literal
10334             VarOrLitOrOpStrOrWord_245 => 'RPerl::NonGenerator', # VarOrLitOrOpStrOrWord -> OpStringOrWord
10335             VariableSymbolOrSelf_246 => 'RPerl::NonGenerator', # VariableSymbolOrSelf -> VARIABLE_SYMBOL
10336             VariableSymbolOrSelf_247 => 'RPerl::NonGenerator', # VariableSymbolOrSelf -> SELF
10337             Literal_248 => 'RPerl::Operation::Expression::SubExpression::Literal::Number', # Literal -> LITERAL_NUMBER
10338             Literal_249 => 'RPerl::Operation::Expression::SubExpression::Literal::String', # Literal -> LITERAL_STRING
10339             OpNamedScolonOrSubExp_250 => 'RPerl::NonGenerator', # OpNamedScolonOrSubExp -> OP01_NAMED_SCOLON
10340             OpNamedScolonOrSubExp_251 => 'RPerl::NonGenerator', # OpNamedScolonOrSubExp -> OP10_NAMED_UNARY_SCOLON
10341             OpNamedScolonOrSubExp_252 => 'RPerl::NonGenerator', # OpNamedScolonOrSubExp -> SubExpression ';'
10342             OpNamedScolonOrSubExpIn_253 => 'RPerl::NonGenerator', # OpNamedScolonOrSubExpIn -> OP01_NAMED_SCOLON
10343             OpNamedScolonOrSubExpIn_254 => 'RPerl::NonGenerator', # OpNamedScolonOrSubExpIn -> OP10_NAMED_UNARY_SCOLON
10344             OpNamedScolonOrSubExpIn_255 => 'RPerl::NonGenerator', # OpNamedScolonOrSubExpIn -> SubExpressionOrInput ';'
10345             OpStringOrWord_256 => 'RPerl::NonGenerator', # OpStringOrWord -> OP24_LOGICAL_OR_XOR
10346             OpStringOrWord_257 => 'RPerl::NonGenerator', # OpStringOrWord -> OP23_LOGICAL_AND
10347             OpStringOrWord_258 => 'RPerl::NonGenerator', # OpStringOrWord -> OP22_LOGICAL_NEG
10348             OpStringOrWord_259 => 'RPerl::NonGenerator', # OpStringOrWord -> OP19_LOOP_CONTROL_SCOLON
10349             OpStringOrWord_260 => 'RPerl::NonGenerator', # OpStringOrWord -> OP19_LOOP_CONTROL
10350             OpStringOrWord_261 => 'RPerl::NonGenerator', # OpStringOrWord -> OP12_COMPARE_EQ_NE
10351             OpStringOrWord_262 => 'RPerl::NonGenerator', # OpStringOrWord -> OP11_COMPARE_LT_GT
10352             OpStringOrWord_263 => 'RPerl::NonGenerator', # OpStringOrWord -> OP10_NAMED_UNARY
10353             OpStringOrWord_264 => 'RPerl::NonGenerator', # OpStringOrWord -> OP08_MATH_ADD_SUB
10354             OpStringOrWord_265 => 'RPerl::NonGenerator', # OpStringOrWord -> OP07_MATH_MULT_DIV_MOD
10355             OpStringOrWord_266 => 'RPerl::NonGenerator', # OpStringOrWord -> OP07_STRING_REPEAT
10356             OpStringOrWord_267 => 'RPerl::NonGenerator', # OpStringOrWord -> OP01_NAMED
10357             OpStringOrWord_268 => 'RPerl::NonGenerator', # OpStringOrWord -> OP01_CLOSE
10358             OpStringOrWord_269 => 'RPerl::NonGenerator', # OpStringOrWord -> OP01_OPEN
10359             OpStringOrWord_270 => 'RPerl::NonGenerator', # OpStringOrWord -> OP01_NAMED_VOID
10360             OpStringOrWord_271 => 'RPerl::NonGenerator', # OpStringOrWord -> OP01_PRINT
10361             OpStringOrWord_272 => 'RPerl::NonGenerator', # OpStringOrWord -> WORD
10362             };
10363              
10364             1;
10365             }
10366              
10367              
10368             =for None
10369              
10370             =cut
10371              
10372              
10373             #line 10373 lib/RPerl/Grammar.pm
10374              
10375              
10376              
10377             1;