diff --git a/README.md b/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..2e1132622c08fd68d804056576166bbab01af036
--- /dev/null
+++ b/README.md
@@ -0,0 +1,3 @@
+# Poject set up
+
+1. 
\ No newline at end of file
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 1784a2b082ce46ee87fd97e36d0760824b03cc65..67e2605a12dec9cb6fc68325684defc1725a666f 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -10,6 +10,7 @@ plugins {
     // Apply the application plugin to add support for building a CLI application in Java.
     application
     antlr
+    java
 }
 
 repositories {
@@ -59,6 +60,17 @@ application {
     mainClass.set("githubsqlfinder.App")
 }
 
+//val mode: String by project.extra
+
+// Set the default value for the parameter
+//project.extra["mode"] = "1"
+
+// Define your run task
+tasks.named<JavaExec>("run") {
+    // Pass the custom parameter as an argument to your application
+    args(System.getProperty("files", "100"), System.getProperty("batch", "100"), System.getProperty("mode", "2"), System.getProperty("offset", "0"), System.getProperty("sample", "1"))
+}
+
 tasks.named<Test>("test") {
     // Use JUnit Platform for unit tests.
     useJUnitPlatform()
diff --git a/app/sample.db b/app/sample.db
new file mode 100644
index 0000000000000000000000000000000000000000..74b87f052289e1921c5ccfe6353c957d1fd09cf0
Binary files /dev/null and b/app/sample.db differ
diff --git a/app/src/main/antlr/PhpLexer.g4 b/app/src/main/antlr/PhpLexer.g4
new file mode 100644
index 0000000000000000000000000000000000000000..b516acb5bd35b91807608dad42be9a3a37c81a68
--- /dev/null
+++ b/app/src/main/antlr/PhpLexer.g4
@@ -0,0 +1,386 @@
+/*
+PHP grammar.
+The MIT License (MIT).
+Copyright (c) 2015-2020, Ivan Kochurkin (kvanttt@gmail.com), Positive Technologies.
+Copyright (c) 2019, Thierry Marianne (thierry.marianne@weaving-the-web.org)
+Copyright (c) 2019-2020, Student Main for php7, php8 support.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+// $antlr-format alignTrailingComments true, columnLimit 150, maxEmptyLinesToKeep 1, reflowComments false, useTab false
+// $antlr-format allowShortRulesOnASingleLine true, allowShortBlocksOnASingleLine true, minEmptyLines 0, alignSemicolons ownLine
+// $antlr-format alignColons trailing, singleLineOverrulesHangingColon true, alignLexerCommands true, alignLabels true, alignTrailers true
+
+lexer grammar PhpLexer;
+
+channels {
+    PhpComments,
+    ErrorLexem,
+    SkipChannel
+}
+
+options {
+    superClass = PhpLexerBase;
+    caseInsensitive = true;
+}
+
+// Insert here @header for C++ lexer.
+
+SeaWhitespace  : [ \t\r\n]+ -> channel(HIDDEN);
+HtmlText       : ~[<#]+;
+XmlStart       : '<?xml'              -> pushMode(XML);
+PHPStartEcho   : PhpStartEchoFragment -> type(Echo), pushMode(PHP);
+PHPStart       : PhpStartFragment     -> channel(SkipChannel), pushMode(PHP);
+HtmlScriptOpen : '<script'            { this._scriptTag = true; } -> pushMode(INSIDE);
+HtmlStyleOpen  : '<style'             { this._styleTag = true; } -> pushMode(INSIDE);
+HtmlComment    : '<!' '--' .*? '-->'  -> channel(HIDDEN);
+HtmlDtd        : '<!' .*? '>';
+HtmlOpen       : '<'       -> pushMode(INSIDE);
+Shebang        : '#'       { this.IsNewLineOrStart(-2) }? '!' ~[\r\n]*;
+NumberSign     : '#' ~'<'* -> more;
+Error          : .         -> channel(ErrorLexem);
+
+// TODO: parse xml attributes.
+mode XML;
+
+XmlText  : ~'?'+;
+XmlClose : '?>' -> popMode;
+XmlText2 : '?'  -> type(XmlText);
+
+mode INSIDE;
+
+PHPStartEchoInside : PhpStartEchoFragment -> type(Echo), pushMode(PHP);
+PHPStartInside     : PhpStartFragment     -> channel(SkipChannel), pushMode(PHP);
+HtmlClose          : '>'                  { this.PushModeOnHtmlClose(); };
+HtmlSlashClose     : '/>'                 -> popMode;
+HtmlSlash          : '/';
+HtmlEquals         : '=';
+
+HtmlStartQuoteString       : '\\'? '\'' -> pushMode(HtmlQuoteStringMode);
+HtmlStartDoubleQuoteString : '\\'? '"'  -> pushMode(HtmlDoubleQuoteStringMode);
+HtmlHex                    : '#' HexDigit+;
+HtmlDecimal                : Digit+;
+HtmlSpace                  : [ \t\r\n]+ -> channel(HIDDEN);
+HtmlName                   : HtmlNameStartChar HtmlNameChar*;
+ErrorInside                : . -> channel(ErrorLexem);
+
+mode HtmlQuoteStringMode;
+
+PHPStartEchoInsideQuoteString : PhpStartEchoFragment -> type(Echo), pushMode(PHP);
+PHPStartInsideQuoteString     : PhpStartFragment     -> channel(SkipChannel), pushMode(PHP);
+HtmlEndQuoteString            : '\'' '\''?           -> popMode;
+HtmlQuoteString               : ~[<']+;
+ErrorHtmlQuote                : . -> channel(ErrorLexem);
+
+mode HtmlDoubleQuoteStringMode;
+
+PHPStartEchoDoubleQuoteString : PhpStartEchoFragment -> type(Echo), pushMode(PHP);
+PHPStartDoubleQuoteString     : PhpStartFragment     -> channel(SkipChannel), pushMode(PHP);
+HtmlEndDoubleQuoteString      : '"' '"'?             -> popMode;
+HtmlDoubleQuoteString         : ~[<"]+;
+ErrorHtmlDoubleQuote          : . -> channel(ErrorLexem);
+
+// Parse JavaScript with https://github.com/antlr/grammars-v4/tree/master/javascript if necessary.
+// Php blocks can exist inside Script blocks too.
+mode SCRIPT;
+
+ScriptText: ~'<'+;
+// TODO: handle JS strings, but handle <?php tags inside them
+//ScriptString:             '"' (~'"' | '\\' ('\r'? '\n' | .))* '"' -> type(ScriptText);
+//ScriptString2:            '\'' (~'\'' | '\\' ('\r'? '\n' | .))* '\'' -> type(ScriptText);
+HtmlScriptClose          : '</' 'script'? '>'   -> popMode;
+PHPStartInsideScriptEcho : PhpStartEchoFragment -> type(Echo), pushMode(PHP);
+PHPStartInsideScript     : PhpStartFragment     -> channel(SkipChannel), pushMode(PHP);
+ScriptText2              : '<'                  -> type(ScriptText);
+
+mode STYLE;
+
+StyleBody: .*? '</' 'style'? '>' -> popMode;
+
+mode PHP;
+
+PHPEnd            : ('?' | '%'    {this.HasAspTags()}?) '>' | '</script>' {this.HasPhpScriptTag()}?;
+Whitespace        : [ \t\r\n]+    -> channel(SkipChannel);
+MultiLineComment  : '/*' .*? '*/' -> channel(PhpComments);
+SingleLineComment : '//'          -> channel(SkipChannel), pushMode(SingleLineCommentMode);
+ShellStyleComment : '#'           -> channel(SkipChannel), pushMode(SingleLineCommentMode);
+
+AttributeStart: '#[';
+
+Abstract        : 'abstract';
+Array           : 'array';
+As              : 'as';
+BinaryCast      : 'binary';
+BoolType        : 'bool' 'ean'?;
+BooleanConstant : 'true' | 'false';
+Break           : 'break';
+Callable        : 'callable';
+Case            : 'case';
+Catch           : 'catch';
+Class           : 'class';
+Clone           : 'clone';
+Const           : 'const';
+Continue        : 'continue';
+Declare         : 'declare';
+Default         : 'default';
+Do              : 'do';
+DoubleCast      : 'real';
+DoubleType      : 'double';
+Echo            : 'echo';
+Else            : 'else';
+ElseIf          : 'elseif';
+Empty           : 'empty';
+Enum_           : 'enum';
+
+EndDeclare : 'enddeclare';
+EndFor     : 'endfor';
+EndForeach : 'endforeach';
+EndIf      : 'endif';
+EndSwitch  : 'endswitch';
+EndWhile   : 'endwhile';
+
+Eval        : 'eval';
+Exit        : 'die';
+Extends     : 'extends';
+Final       : 'final';
+Finally     : 'finally';
+FloatCast   : 'float';
+For         : 'for';
+Foreach     : 'foreach';
+Function_   : 'function';
+Global      : 'global';
+Goto        : 'goto';
+If          : 'if';
+Implements  : 'implements';
+Import      : 'import';
+Include     : 'include';
+IncludeOnce : 'include_once';
+InstanceOf  : 'instanceof';
+InsteadOf   : 'insteadof';
+Int8Cast    : 'int8';
+Int16Cast   : 'int16';
+Int64Type   : 'int64';
+IntType     : 'int' 'eger'?;
+Interface   : 'interface';
+IsSet       : 'isset';
+List        : 'list';
+LogicalAnd  : 'and';
+LogicalOr   : 'or';
+LogicalXor  : 'xor';
+Match_      : 'match';
+Namespace   : 'namespace';
+New         : 'new';
+Null        : 'null';
+ObjectType  : 'object';
+Parent_     : 'parent';
+Partial     : 'partial';
+Print       : 'print';
+Private     : 'private';
+Protected   : 'protected';
+Public      : 'public';
+Readonly    : 'readonly';
+Require     : 'require';
+RequireOnce : 'require_once';
+Resource    : 'resource';
+Return      : 'return';
+Static      : 'static';
+StringType  : 'string';
+Switch      : 'switch';
+Throw       : 'throw';
+Trait       : 'trait';
+Try         : 'try';
+Typeof      : 'clrtypeof';
+UintCast    : 'uint' ('8' | '16' | '64')?;
+UnicodeCast : 'unicode';
+Unset       : 'unset';
+Use         : 'use';
+Var         : 'var';
+While       : 'while';
+Yield       : 'yield';
+From        : 'from';
+LambdaFn    : 'fn';
+Ticks       : 'ticks';
+Encoding    : 'encoding';
+StrictTypes : 'strict_types';
+
+Get         : '__get';
+Set         : '__set';
+Call        : '__call';
+CallStatic  : '__callstatic';
+Constructor : '__construct';
+Destruct    : '__destruct';
+Wakeup      : '__wakeup';
+Sleep       : '__sleep';
+Autoload    : '__autoload';
+IsSet__     : '__isset';
+Unset__     : '__unset';
+ToString__  : '__tostring';
+Invoke      : '__invoke';
+SetState    : '__set_state';
+Clone__     : '__clone';
+DebugInfo   : '__debuginfo';
+Namespace__ : '__namespace__';
+Class__     : '__class__';
+Traic__     : '__trait__';
+Function__  : '__function__';
+Method__    : '__method__';
+Line__      : '__line__';
+File__      : '__file__';
+Dir__       : '__dir__';
+
+Spaceship        : '<=>';
+Lgeneric         : '<:';
+Rgeneric         : ':>';
+DoubleArrow      : '=>';
+Inc              : '++';
+Dec              : '--';
+IsIdentical      : '===';
+IsNoidentical    : '!==';
+IsEqual          : '==';
+IsNotEq          : '<>' | '!=';
+IsSmallerOrEqual : '<=';
+IsGreaterOrEqual : '>=';
+PlusEqual        : '+=';
+MinusEqual       : '-=';
+MulEqual         : '*=';
+Pow              : '**';
+PowEqual         : '**=';
+DivEqual         : '/=';
+Concaequal       : '.=';
+ModEqual         : '%=';
+ShiftLeftEqual   : '<<=';
+ShiftRightEqual  : '>>=';
+AndEqual         : '&=';
+OrEqual          : '|=';
+XorEqual         : '^=';
+BooleanOr        : '||';
+BooleanAnd       : '&&';
+
+NullCoalescing      : '??';
+NullCoalescingEqual : '??=';
+
+ShiftLeft          : '<<';
+ShiftRight         : '>>';
+DoubleColon        : '::';
+ObjectOperator     : '->';
+NamespaceSeparator : '\\';
+Ellipsis           : '...';
+Less               : '<';
+Greater            : '>';
+Ampersand          : '&';
+Pipe               : '|';
+Bang               : '!';
+Caret              : '^';
+Plus               : '+';
+Minus              : '-';
+Asterisk           : '*';
+Percent            : '%';
+Divide             : '/';
+Tilde              : '~';
+SuppressWarnings   : '@';
+Dollar             : '$';
+Dot                : '.';
+QuestionMark       : '?';
+OpenRoundBracket   : '(';
+CloseRoundBracket  : ')';
+OpenSquareBracket  : '[';
+CloseSquareBracket : ']';
+OpenCurlyBracket   : '{';
+CloseCurlyBracket  : '}' { this.PopModeOnCurlyBracketClose(); };
+Comma              : ',';
+Colon              : ':';
+SemiColon          : ';';
+Eq                 : '=';
+Quote              : '\'';
+BackQuote          : '`';
+
+VarName : '$' NameString;
+Label   : [a-z_][a-z_0-9]*;
+Octal   : '0' 'o'? OctalDigit+ ('_' OctalDigit+)*;
+Decimal : '0' | NonZeroDigit Digit* ('_' Digit+)*;
+Real    : (LNum '.' LNum? | LNum? '.' LNum) ExponentPart? | LNum+ ExponentPart;
+Hex     : '0x' HexDigit+ ('_' HexDigit+)*;
+Binary  : '0b' [01]+ ('_' [01]+)*;
+
+BackQuoteString   : '`' ~'`'* '`';
+SingleQuoteString : '\'' (~('\'' | '\\') | '\\' .)* '\'';
+DoubleQuote       : '"' -> pushMode(InterpolationString);
+
+StartNowDoc:
+    '<<<' [ \t]* '\'' NameString '\'' { this.ShouldPushHereDocMode(1) }? -> pushMode(HereDoc)
+;
+StartHereDoc : '<<<' [ \t]* NameString { this.ShouldPushHereDocMode(1) }? -> pushMode(HereDoc);
+ErrorPhp     : .                       -> channel(ErrorLexem);
+
+mode InterpolationString;
+
+VarNameInInterpolation : '$' NameString -> type(VarName); // TODO: fix such cases: "$people->john"
+DollarString           : '$'            -> type(StringPart);
+CurlyDollar:
+    '{' { this.IsCurlyDollar(1) }? { this.SetInsideString(); } -> channel(SkipChannel), pushMode(PHP)
+;
+CurlyString                : '{'    -> type(StringPart);
+EscapedChar                : '\\' . -> type(StringPart);
+DoubleQuoteInInterpolation : '"'    -> type(DoubleQuote), popMode;
+UnicodeEscape              : '\\u{' [a-z0-9][a-z0-9]+ '}';
+StringPart                 : ~[${\\"]+;
+
+mode SingleLineCommentMode;
+
+Comment                 : ~[\r\n?]+ -> channel(PhpComments);
+PHPEndSingleLineComment : '?' '>';
+CommentQuestionMark     : '?'    -> type(Comment), channel(PhpComments);
+CommentEnd              : [\r\n] -> channel(SkipChannel), popMode; // exit from comment.
+
+mode HereDoc;
+// TODO: interpolation for heredoc strings.
+
+HereDocText: ~[\r\n]*? ('\r'? '\n' | '\r');
+
+// fragments.
+// '<?=' will be transformed to 'echo' token.
+// '<?= "Hello world"; ?>' will be transformed to '<?php echo "Hello world"; ?>'
+fragment PhpStartEchoFragment : '<' ('?' '=' |    { this.HasAspTags() }? '%' '=');
+fragment PhpStartFragment     : '<' ('?' 'php'? | { this.HasAspTags() }? '%');
+fragment NameString : [a-zA-Z_\u0080-\ufffe][a-zA-Z0-9_\u0080-\ufffe]*;
+fragment HtmlNameChar :
+    HtmlNameStartChar
+    | '-'
+    | '_'
+    | '.'
+    | Digit
+    | '\u00B7'
+    | '\u0300' ..'\u036F'
+    | '\u203F' ..'\u2040'
+;
+fragment HtmlNameStartChar :
+    [:a-zA-Z]
+    | '\u2070' ..'\u218F'
+    | '\u2C00' ..'\u2FEF'
+    | '\u3001' ..'\uD7FF'
+    | '\uF900' ..'\uFDCF'
+    | '\uFDF0' ..'\uFFFD'
+;
+fragment LNum         : Digit+ ('_' Digit+)*;
+fragment ExponentPart : 'e' [+-]? LNum;
+fragment NonZeroDigit : [1-9];
+fragment Digit        : [0-9];
+fragment OctalDigit   : [0-7];
+fragment HexDigit     : [a-f0-9];
\ No newline at end of file
diff --git a/app/src/main/antlr/PhpParser.g4 b/app/src/main/antlr/PhpParser.g4
new file mode 100644
index 0000000000000000000000000000000000000000..3ba7eb3dd6eb22df32e3186862ae128e5e632b6c
--- /dev/null
+++ b/app/src/main/antlr/PhpParser.g4
@@ -0,0 +1,980 @@
+/*
+PHP grammar.
+The MIT License (MIT).
+Copyright (c) 2015-2020, Ivan Kochurkin (kvanttt@gmail.com), Positive Technologies.
+Copyright (c) 2019-2020, Student Main for php7, php8 support.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+// $antlr-format alignTrailingComments true, columnLimit 150, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments false, useTab false
+// $antlr-format allowShortRulesOnASingleLine false, allowShortBlocksOnASingleLine true, alignSemicolons hanging, alignColons hanging
+
+parser grammar PhpParser;
+
+options {
+    tokenVocab = PhpLexer;
+}
+
+// HTML
+// Also see here: https://github.com/antlr/grammars-v4/tree/master/html
+
+htmlDocument
+    : Shebang? (inlineHtml | phpBlock)* EOF
+    ;
+
+inlineHtml
+    : htmlElement+
+    | scriptText
+    ;
+
+// TODO: split into html, css and xml elements
+htmlElement
+    : HtmlDtd
+    | HtmlClose
+    | HtmlStyleOpen
+    | HtmlOpen
+    | HtmlName
+    | HtmlSlashClose
+    | HtmlSlash
+    | HtmlText
+    | HtmlEquals
+    | HtmlStartQuoteString
+    | HtmlEndQuoteString
+    | HtmlStartDoubleQuoteString
+    | HtmlEndDoubleQuoteString
+    | HtmlHex
+    | HtmlDecimal
+    | HtmlQuoteString
+    | HtmlDoubleQuoteString
+    | StyleBody
+    | HtmlScriptOpen
+    | HtmlScriptClose
+    | XmlStart XmlText* XmlClose
+    ;
+
+// Script
+// Parse JavaScript with https://github.com/antlr/grammars-v4/tree/master/javascript if necessary.
+
+scriptText
+    : ScriptText+
+    ;
+
+// PHP
+
+phpBlock
+    : importStatement* topStatement+
+    ;
+
+importStatement
+    : Import Namespace namespaceNameList SemiColon
+    ;
+
+topStatement
+    : statement
+    | useDeclaration
+    | namespaceDeclaration
+    | functionDeclaration
+    | classDeclaration
+    | globalConstantDeclaration
+    | enumDeclaration
+    ;
+
+useDeclaration
+    : Use (Function_ | Const)? useDeclarationContentList SemiColon
+    ;
+
+useDeclarationContentList
+    : '\\'? useDeclarationContent (',' '\\'? useDeclarationContent)*
+    ;
+
+useDeclarationContent
+    : namespaceNameList
+    ;
+
+namespaceDeclaration
+    : Namespace (
+        namespaceNameList? OpenCurlyBracket namespaceStatement* CloseCurlyBracket
+        | namespaceNameList SemiColon
+    )
+    ;
+
+namespaceStatement
+    : statement
+    | useDeclaration
+    | functionDeclaration
+    | classDeclaration
+    | globalConstantDeclaration
+    ;
+
+functionDeclaration
+    : attributes? Function_ '&'? identifier typeParameterListInBrackets? '(' formalParameterList ')' (
+        ':' QuestionMark? typeHint
+    )? blockStatement
+    ;
+
+classDeclaration
+    : attributes? Private? modifier? Partial? (
+        classEntryType identifier typeParameterListInBrackets? (Extends qualifiedStaticTypeRef)? (
+            Implements interfaceList
+        )?
+        | Interface identifier typeParameterListInBrackets? (Extends interfaceList)?
+    ) OpenCurlyBracket classStatement* CloseCurlyBracket
+    ;
+
+classEntryType
+    : Class
+    | Trait
+    ;
+
+interfaceList
+    : qualifiedStaticTypeRef (',' qualifiedStaticTypeRef)*
+    ;
+
+typeParameterListInBrackets
+    : '<:' typeParameterList ':>'
+    | '<:' typeParameterWithDefaultsList ':>'
+    | '<:' typeParameterList ',' typeParameterWithDefaultsList ':>'
+    ;
+
+typeParameterList
+    : typeParameterDecl (',' typeParameterDecl)*
+    ;
+
+typeParameterWithDefaultsList
+    : typeParameterWithDefaultDecl (',' typeParameterWithDefaultDecl)*
+    ;
+
+typeParameterDecl
+    : attributes? identifier
+    ;
+
+typeParameterWithDefaultDecl
+    : attributes? identifier Eq (qualifiedStaticTypeRef | primitiveType)
+    ;
+
+genericDynamicArgs
+    : '<:' typeRef (',' typeRef)* ':>'
+    ;
+
+attributes
+    : attributeGroup+
+    ;
+
+attributeGroup
+    : AttributeStart (identifier ':')? attribute (',' attribute)* ']'
+    ;
+
+attribute
+    : qualifiedNamespaceName arguments?
+    ;
+
+innerStatementList
+    : innerStatement*
+    ;
+
+innerStatement
+    : statement
+    | functionDeclaration
+    | classDeclaration
+    ;
+
+// Statements
+
+statement
+    : identifier ':'
+    | blockStatement
+    | ifStatement
+    | whileStatement
+    | doWhileStatement
+    | forStatement
+    | switchStatement
+    | breakStatement
+    | continueStatement
+    | returnStatement
+    | yieldExpression SemiColon
+    | globalStatement
+    | staticVariableStatement
+    | echoStatement
+    | expressionStatement
+    | unsetStatement
+    | foreachStatement
+    | tryCatchFinally
+    | throwStatement
+    | gotoStatement
+    | declareStatement
+    | emptyStatement_
+    | inlineHtmlStatement
+    ;
+
+emptyStatement_
+    : SemiColon
+    ;
+
+blockStatement
+    : OpenCurlyBracket innerStatementList CloseCurlyBracket
+    ;
+
+ifStatement
+    : If parentheses statement elseIfStatement* elseStatement?
+    | If parentheses ':' innerStatementList elseIfColonStatement* elseColonStatement? EndIf SemiColon
+    ;
+
+elseIfStatement
+    : ElseIf parentheses statement
+    ;
+
+elseIfColonStatement
+    : ElseIf parentheses ':' innerStatementList
+    ;
+
+elseStatement
+    : Else statement
+    ;
+
+elseColonStatement
+    : Else ':' innerStatementList
+    ;
+
+whileStatement
+    : While parentheses (statement | ':' innerStatementList EndWhile SemiColon)
+    ;
+
+doWhileStatement
+    : Do statement While parentheses SemiColon
+    ;
+
+forStatement
+    : For '(' forInit? SemiColon expressionList? SemiColon forUpdate? ')' (
+        statement
+        | ':' innerStatementList EndFor SemiColon
+    )
+    ;
+
+forInit
+    : expressionList
+    ;
+
+forUpdate
+    : expressionList
+    ;
+
+switchStatement
+    : Switch parentheses (
+        OpenCurlyBracket SemiColon? switchBlock* CloseCurlyBracket
+        | ':' SemiColon? switchBlock* EndSwitch SemiColon
+    )
+    ;
+
+switchBlock
+    : ((Case expression | Default) (':' | SemiColon))+ innerStatementList
+    ;
+
+breakStatement
+    : Break expression? SemiColon
+    ;
+
+continueStatement
+    : Continue expression? SemiColon
+    ;
+
+returnStatement
+    : Return expression? SemiColon
+    ;
+
+expressionStatement
+    : expression SemiColon
+    ;
+
+unsetStatement
+    : Unset '(' chainList ')' SemiColon
+    ;
+
+foreachStatement
+    : Foreach (
+        '(' expression As arrayDestructuring ')'
+        | '(' chain As '&'? assignable ('=>' '&'? chain)? ')'
+        | '(' expression As assignable ('=>' '&'? chain)? ')'
+        | '(' chain As List '(' assignmentList ')' ')'
+    ) (statement | ':' innerStatementList EndForeach SemiColon)
+    ;
+
+tryCatchFinally
+    : Try blockStatement (catchClause+ finallyStatement? | catchClause* finallyStatement)
+    ;
+
+catchClause
+    : Catch '(' qualifiedStaticTypeRef ('|' qualifiedStaticTypeRef)* VarName? ')' blockStatement
+    ;
+
+finallyStatement
+    : Finally blockStatement
+    ;
+
+throwStatement
+    : Throw expression SemiColon
+    ;
+
+gotoStatement
+    : Goto identifier SemiColon
+    ;
+
+declareStatement
+    : Declare '(' declareList ')' (statement | ':' innerStatementList EndDeclare SemiColon)
+    ;
+
+inlineHtmlStatement
+    : inlineHtml+
+    ;
+
+declareList
+    : directive (',' directive)*
+    ;
+
+directive
+    : Ticks Eq (numericConstant | Real)
+    | Encoding Eq SingleQuoteString
+    | StrictTypes Eq numericConstant
+    ;
+
+formalParameterList
+    : formalParameter? (',' formalParameter)* ','?
+    ;
+
+formalParameter
+    : attributes? memberModifier* QuestionMark? typeHint? '&'? '...'? variableInitializer
+    ;
+
+typeHint
+    : qualifiedStaticTypeRef
+    | Callable
+    | primitiveType
+    | typeHint '|' typeHint
+    ;
+
+globalStatement
+    : Global globalVar (',' globalVar)* SemiColon
+    ;
+
+globalVar
+    : VarName
+    | Dollar chain
+    | Dollar OpenCurlyBracket expression CloseCurlyBracket
+    ;
+
+echoStatement
+    : Echo expressionList SemiColon
+    ;
+
+staticVariableStatement
+    : Static variableInitializer (',' variableInitializer)* SemiColon
+    ;
+
+classStatement
+    : attributes? (
+        propertyModifiers typeHint? variableInitializer (',' variableInitializer)* SemiColon
+        | memberModifiers? (
+            Const typeHint? identifierInitializer (',' identifierInitializer)* SemiColon
+            | Function_ '&'? identifier typeParameterListInBrackets? '(' formalParameterList ')' (
+                baseCtorCall
+                | returnTypeDecl
+            )? methodBody
+        )
+    )
+    | Use qualifiedNamespaceNameList traitAdaptations
+    ;
+
+traitAdaptations
+    : SemiColon
+    | OpenCurlyBracket traitAdaptationStatement* CloseCurlyBracket
+    ;
+
+traitAdaptationStatement
+    : traitPrecedence
+    | traitAlias
+    ;
+
+traitPrecedence
+    : qualifiedNamespaceName '::' identifier InsteadOf qualifiedNamespaceNameList SemiColon
+    ;
+
+traitAlias
+    : traitMethodReference As (memberModifier | memberModifier? identifier) SemiColon
+    ;
+
+traitMethodReference
+    : (qualifiedNamespaceName '::')? identifier
+    ;
+
+baseCtorCall
+    : ':' identifier arguments?
+    ;
+
+returnTypeDecl
+    : ':' QuestionMark? typeHint
+    ;
+
+methodBody
+    : SemiColon
+    | blockStatement
+    ;
+
+propertyModifiers
+    : memberModifiers
+    | Var
+    ;
+
+memberModifiers
+    : memberModifier+
+    ;
+
+variableInitializer
+    : VarName (Eq constantInitializer)?
+    ;
+
+identifierInitializer
+    : identifier Eq constantInitializer
+    ;
+
+globalConstantDeclaration
+    : attributes? Const identifierInitializer (',' identifierInitializer)* SemiColon
+    ;
+
+enumDeclaration
+    : Enum_ identifier (Colon (IntType | StringType))? (Implements interfaceList)? OpenCurlyBracket enumItem* CloseCurlyBracket
+    ;
+
+enumItem
+    : Case identifier (Eq expression)? SemiColon
+    | memberModifiers? functionDeclaration
+    | Use qualifiedNamespaceNameList traitAdaptations
+    ;
+
+expressionList
+    : expression (',' expression)*
+    ;
+
+parentheses
+    : '(' (expression | yieldExpression) ')'
+    ;
+
+// Expressions
+// Grouped by priorities: http://php.net/manual/en/language.operators.precedence.php
+expression
+    : Clone expression                                            # CloneExpression
+    | newExpr                                                     # NewExpression
+    | stringConstant '[' expression ']'                           # IndexerExpression
+    | '(' castOperation ')' expression                            # CastExpression
+    | ('~' | '@') expression                                      # UnaryOperatorExpression
+    | ('!' | '+' | '-') expression                                # UnaryOperatorExpression
+    | ('++' | '--') chain                                         # PrefixIncDecExpression
+    | chain ('++' | '--')                                         # PostfixIncDecExpression
+    | Print expression                                            # PrintExpression
+    | arrayCreation                                               # ArrayCreationExpression
+    | chain                                                       # ChainExpression
+    | constant                                                    # ScalarExpression
+    | string                                                      # ScalarExpression
+    | Label                                                       # ScalarExpression
+    | BackQuoteString                                             # BackQuoteStringExpression
+    | parentheses                                                 # ParenthesisExpression
+    | Yield                                                       # SpecialWordExpression
+    | List '(' assignmentList ')' Eq expression                   # SpecialWordExpression
+    | IsSet '(' chainList ')'                                     # SpecialWordExpression
+    | Empty '(' chain ')'                                         # SpecialWordExpression
+    | Eval '(' expression ')'                                     # SpecialWordExpression
+    | Exit ( '(' ')' | parentheses)?                              # SpecialWordExpression
+    | (Include | IncludeOnce) expression                          # SpecialWordExpression
+    | (Require | RequireOnce) expression                          # SpecialWordExpression
+    | lambdaFunctionExpr                                          # LambdaFunctionExpression
+    | matchExpr                                                   # MatchExpression
+    | <assoc = right> expression op = '**' expression             # ArithmeticExpression
+    | expression InstanceOf typeRef                               # InstanceOfExpression
+    | expression op = ('*' | Divide | '%') expression             # ArithmeticExpression
+    | expression op = ('+' | '-' | '.') expression                # ArithmeticExpression
+    | expression op = ('<<' | '>>') expression                    # ComparisonExpression
+    | expression op = (Less | '<=' | Greater | '>=') expression   # ComparisonExpression
+    | expression op = ('===' | '!==' | '==' | IsNotEq) expression # ComparisonExpression
+    | expression op = '&' expression                              # BitwiseExpression
+    | expression op = '^' expression                              # BitwiseExpression
+    | expression op = '|' expression                              # BitwiseExpression
+    | expression op = '&&' expression                             # BitwiseExpression
+    | expression op = '||' expression                             # BitwiseExpression
+    | expression op = QuestionMark expression? ':' expression     # ConditionalExpression
+    | expression op = '??' expression                             # NullCoalescingExpression
+    | expression op = '<=>' expression                            # SpaceshipExpression
+    | Throw expression                                            # SpecialWordExpression
+    | arrayDestructuring Eq expression                            # ArrayDestructExpression
+    | assignable assignmentOperator attributes? expression        # AssignmentExpression
+    | assignable Eq attributes? '&' (chain | newExpr)             # AssignmentExpression
+    | expression op = LogicalAnd expression                       # LogicalExpression
+    | expression op = LogicalXor expression                       # LogicalExpression
+    | expression op = LogicalOr expression                        # LogicalExpression
+    ;
+
+assignable
+    : chain
+    | arrayCreation
+    ;
+
+arrayCreation
+    : (Array '(' arrayItemList? ')' | '[' arrayItemList? ']') ('[' expression ']')?
+    ;
+
+arrayDestructuring
+    : '[' ','* indexedDestructItem (','+ indexedDestructItem)* ','* ']'
+    | '[' keyedDestructItem (','+ keyedDestructItem)* ','? ']'
+    ;
+
+indexedDestructItem
+    : '&'? chain
+    ;
+
+keyedDestructItem
+    : (expression '=>')? '&'? chain
+    ;
+
+lambdaFunctionExpr
+    : Static? Function_ '&'? '(' formalParameterList ')' lambdaFunctionUseVars? (':' typeHint)? blockStatement
+    | LambdaFn '(' formalParameterList ')' '=>' expression
+    ;
+
+matchExpr
+    : Match_ '(' expression ')' OpenCurlyBracket matchItem (',' matchItem)* ','? CloseCurlyBracket
+    ;
+
+matchItem
+    : expression (',' expression)* '=>' expression
+    ;
+
+newExpr
+    : New typeRef arguments?
+    ;
+
+assignmentOperator
+    : Eq
+    | '+='
+    | '-='
+    | '*='
+    | '**='
+    | '/='
+    | '.='
+    | '%='
+    | '&='
+    | '|='
+    | '^='
+    | '<<='
+    | '>>='
+    | '??='
+    ;
+
+yieldExpression
+    : Yield (expression ('=>' expression)? | From expression)
+    ;
+
+arrayItemList
+    : arrayItem (',' arrayItem)* ','?
+    ;
+
+arrayItem
+    : expression ('=>' expression)?
+    | (expression '=>')? '&' chain
+    ;
+
+lambdaFunctionUseVars
+    : Use '(' lambdaFunctionUseVar (',' lambdaFunctionUseVar)* ')'
+    ;
+
+lambdaFunctionUseVar
+    : '&'? VarName
+    ;
+
+qualifiedStaticTypeRef
+    : qualifiedNamespaceName genericDynamicArgs?
+    | Static
+    ;
+
+typeRef
+    : (qualifiedNamespaceName | indirectTypeRef) genericDynamicArgs?
+    | primitiveType
+    | Static
+    | anonymousClass
+    ;
+
+anonymousClass
+    : attributes? Private? modifier? Partial? (
+        classEntryType typeParameterListInBrackets? (Extends qualifiedStaticTypeRef)? (
+            Implements interfaceList
+        )?
+        | Interface identifier typeParameterListInBrackets? (Extends interfaceList)?
+    ) OpenCurlyBracket classStatement* CloseCurlyBracket
+    ;
+
+indirectTypeRef
+    : chainBase ('->' keyedFieldName)*
+    ;
+
+qualifiedNamespaceName
+    : Namespace? '\\'? namespaceNameList
+    ;
+
+namespaceNameList
+    : identifier
+    | identifier ('\\' identifier)* ('\\' namespaceNameTail)?
+    ;
+
+namespaceNameTail
+    : identifier (As identifier)?
+    | OpenCurlyBracket namespaceNameTail (',' namespaceNameTail)* ','? CloseCurlyBracket
+    ;
+
+qualifiedNamespaceNameList
+    : qualifiedNamespaceName (',' qualifiedNamespaceName)*
+    ;
+
+arguments
+    : '(' (actualArgument (',' actualArgument)* | yieldExpression)? ','? ')'
+    ;
+
+actualArgument
+    : argumentName? '...'? expression
+    | '&' chain
+    ;
+
+argumentName
+    : identifier ':'
+    ;
+
+constantInitializer
+    : constant
+    | string
+    | Array '(' (arrayItemList ','?)? ')'
+    | '[' (arrayItemList ','?)? ']'
+    | ('+' | '-') constantInitializer
+    | (string | constant) ('.' (string | constant))*
+    ;
+
+constant
+    : Null
+    | literalConstant
+    | magicConstant
+    | classConstant
+    | qualifiedNamespaceName
+    ;
+
+literalConstant
+    : Real
+    | BooleanConstant
+    | numericConstant
+    | stringConstant
+    ;
+
+numericConstant
+    : Octal
+    | Decimal
+    | Hex
+    | Binary
+    ;
+
+classConstant
+    : (Class | Parent_) '::' (identifier | Constructor | Get | Set)
+    | (qualifiedStaticTypeRef | keyedVariable | string) '::' (
+        identifier
+        | keyedVariable
+    ) // 'foo'::$bar works in php7
+    ;
+
+stringConstant
+    : Label
+    ;
+
+string
+    : StartHereDoc HereDocText+
+    | StartNowDoc HereDocText+
+    | SingleQuoteString
+    | DoubleQuote interpolatedStringPart* DoubleQuote
+    ;
+
+interpolatedStringPart
+    : StringPart
+    | UnicodeEscape
+    | chain
+    ;
+
+chainList
+    : chain (',' chain)*
+    ;
+
+chain
+    : chainOrigin memberAccess*
+    //| arrayCreation // [$a,$b]=$c
+    ;
+
+chainOrigin
+    : chainBase
+    | functionCall
+    | '(' newExpr ')'
+    ;
+
+memberAccess
+    : '->' keyedFieldName actualArguments?
+    ;
+
+functionCall
+    : functionCallName actualArguments
+    ;
+
+functionCallName
+    : qualifiedNamespaceName
+    | classConstant
+    | chainBase
+    | parentheses
+    ;
+
+actualArguments
+    : genericDynamicArgs? arguments+ squareCurlyExpression*
+    ;
+
+chainBase
+    : keyedVariable ('::' keyedVariable)?
+    | qualifiedStaticTypeRef '::' keyedVariable
+    ;
+
+keyedFieldName
+    : keyedSimpleFieldName
+    | keyedVariable
+    ;
+
+keyedSimpleFieldName
+    : (identifier | OpenCurlyBracket expression CloseCurlyBracket) squareCurlyExpression*
+    ;
+
+keyedVariable
+    : Dollar* (VarName | Dollar OpenCurlyBracket expression CloseCurlyBracket) squareCurlyExpression*
+    ;
+
+squareCurlyExpression
+    : '[' expression? ']'
+    | OpenCurlyBracket expression CloseCurlyBracket
+    ;
+
+assignmentList
+    : assignmentListElement? (',' assignmentListElement?)*
+    ;
+
+assignmentListElement
+    : chain
+    | List '(' assignmentList ')'
+    | arrayItem
+    ;
+
+modifier
+    : Abstract
+    | Final
+    ;
+
+identifier
+    : Label
+    | Abstract
+    | Array
+    | As
+    | BinaryCast
+    | BoolType
+    | BooleanConstant
+    | Break
+    | Callable
+    | Case
+    | Catch
+    | Class
+    | Clone
+    | Const
+    | Continue
+    | Declare
+    | Default
+    | Do
+    | DoubleCast
+    | DoubleType
+    | Echo
+    | Else
+    | ElseIf
+    | Empty
+    | EndDeclare
+    | EndFor
+    | EndForeach
+    | EndIf
+    | EndSwitch
+    | EndWhile
+    | Eval
+    | Exit
+    | Extends
+    | Final
+    | Finally
+    | FloatCast
+    | For
+    | Foreach
+    | Function_
+    | Global
+    | Goto
+    | If
+    | Implements
+    | Import
+    | Include
+    | IncludeOnce
+    | InstanceOf
+    | InsteadOf
+    | Int16Cast
+    | Int64Type
+    | Int8Cast
+    | Interface
+    | IntType
+    | IsSet
+    | LambdaFn
+    | List
+    | LogicalAnd
+    | LogicalOr
+    | LogicalXor
+    | Namespace
+    | New
+    | Null
+    | ObjectType
+    | Parent_
+    | Partial
+    | Print
+    | Private
+    | Protected
+    | Public
+    | Readonly
+    | Require
+    | RequireOnce
+    | Resource
+    | Return
+    | Static
+    | StringType
+    | Switch
+    | Throw
+    | Trait
+    | Try
+    | Typeof
+    | UintCast
+    | UnicodeCast
+    | Unset
+    | Use
+    | Var
+    | While
+    | Yield
+    | From
+    | Enum_
+    | Match_
+    | Ticks
+    | Encoding
+    | StrictTypes
+    | Get
+    | Set
+    | Call
+    | CallStatic
+    | Constructor
+    | Destruct
+    | Wakeup
+    | Sleep
+    | Autoload
+    | IsSet__
+    | Unset__
+    | ToString__
+    | Invoke
+    | SetState
+    | Clone__
+    | DebugInfo
+    | Namespace__
+    | Class__
+    | Traic__
+    | Function__
+    | Method__
+    | Line__
+    | File__
+    | Dir__
+    ;
+
+memberModifier
+    : Public
+    | Protected
+    | Private
+    | Static
+    | Abstract
+    | Final
+    | Readonly
+    ;
+
+magicConstant
+    : Namespace__
+    | Class__
+    | Traic__
+    | Function__
+    | Method__
+    | Line__
+    | File__
+    | Dir__
+    ;
+
+magicMethod
+    : Get
+    | Set
+    | Call
+    | CallStatic
+    | Constructor
+    | Destruct
+    | Wakeup
+    | Sleep
+    | Autoload
+    | IsSet__
+    | Unset__
+    | ToString__
+    | Invoke
+    | SetState
+    | Clone__
+    | DebugInfo
+    ;
+
+primitiveType
+    : BoolType
+    | IntType
+    | Int64Type
+    | DoubleType
+    | StringType
+    | Resource
+    | ObjectType
+    | Array
+    ;
+
+castOperation
+    : BoolType
+    | Int8Cast
+    | Int16Cast
+    | IntType
+    | Int64Type
+    | UintCast
+    | DoubleCast
+    | DoubleType
+    | FloatCast
+    | StringType
+    | BinaryCast
+    | UnicodeCast
+    | Array
+    | ObjectType
+    | Resource
+    | Unset
+    ;
\ No newline at end of file
diff --git a/app/src/main/java/antlr/PhpLexer.java b/app/src/main/java/antlr/PhpLexer.java
new file mode 100644
index 0000000000000000000000000000000000000000..c47ccf0dddfbe65796031d44385a1b8063405f47
--- /dev/null
+++ b/app/src/main/java/antlr/PhpLexer.java
@@ -0,0 +1,1271 @@
+package antlr;
+
+// Generated from PhpLexer.g4 by ANTLR 4.5
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.TokenStream;
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.atn.*;
+import org.antlr.v4.runtime.dfa.DFA;
+import org.antlr.v4.runtime.misc.*;
+
+@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
+public class PhpLexer extends PhpLexerBase {
+	static { RuntimeMetaData.checkVersion("4.5", RuntimeMetaData.VERSION); }
+
+	protected static final DFA[] _decisionToDFA;
+	protected static final PredictionContextCache _sharedContextCache =
+		new PredictionContextCache();
+	public static final int
+		SeaWhitespace=1, HtmlText=2, XmlStart=3, PHPStart=4, HtmlScriptOpen=5, 
+		HtmlStyleOpen=6, HtmlComment=7, HtmlDtd=8, HtmlOpen=9, Shebang=10, Error=11, 
+		XmlText=12, XmlClose=13, PHPStartInside=14, HtmlClose=15, HtmlSlashClose=16, 
+		HtmlSlash=17, HtmlEquals=18, HtmlStartQuoteString=19, HtmlStartDoubleQuoteString=20, 
+		HtmlHex=21, HtmlDecimal=22, HtmlSpace=23, HtmlName=24, ErrorInside=25, 
+		PHPStartInsideQuoteString=26, HtmlEndQuoteString=27, HtmlQuoteString=28, 
+		ErrorHtmlQuote=29, PHPStartDoubleQuoteString=30, HtmlEndDoubleQuoteString=31, 
+		HtmlDoubleQuoteString=32, ErrorHtmlDoubleQuote=33, ScriptText=34, HtmlScriptClose=35, 
+		PHPStartInsideScript=36, StyleBody=37, PHPEnd=38, Whitespace=39, MultiLineComment=40, 
+		SingleLineComment=41, ShellStyleComment=42, AttributeStart=43, Abstract=44, 
+		Array=45, As=46, BinaryCast=47, BoolType=48, BooleanConstant=49, Break=50, 
+		Callable=51, Case=52, Catch=53, Class=54, Clone=55, Const=56, Continue=57, 
+		Declare=58, Default=59, Do=60, DoubleCast=61, DoubleType=62, Echo=63, 
+		Else=64, ElseIf=65, Empty=66, Enum_=67, EndDeclare=68, EndFor=69, EndForeach=70, 
+		EndIf=71, EndSwitch=72, EndWhile=73, Eval=74, Exit=75, Extends=76, Final=77, 
+		Finally=78, FloatCast=79, For=80, Foreach=81, Function_=82, Global=83, 
+		Goto=84, If=85, Implements=86, Import=87, Include=88, IncludeOnce=89, 
+		InstanceOf=90, InsteadOf=91, Int8Cast=92, Int16Cast=93, Int64Type=94, 
+		IntType=95, Interface=96, IsSet=97, List=98, LogicalAnd=99, LogicalOr=100, 
+		LogicalXor=101, Match_=102, Namespace=103, New=104, Null=105, ObjectType=106, 
+		Parent_=107, Partial=108, Print=109, Private=110, Protected=111, Public=112, 
+		Readonly=113, Require=114, RequireOnce=115, Resource=116, Return=117, 
+		Static=118, StringType=119, Switch=120, Throw=121, Trait=122, Try=123, 
+		Typeof=124, UintCast=125, UnicodeCast=126, Unset=127, Use=128, Var=129, 
+		While=130, Yield=131, From=132, LambdaFn=133, Ticks=134, Encoding=135, 
+		StrictTypes=136, Get=137, Set=138, Call=139, CallStatic=140, Constructor=141, 
+		Destruct=142, Wakeup=143, Sleep=144, Autoload=145, IsSet__=146, Unset__=147, 
+		ToString__=148, Invoke=149, SetState=150, Clone__=151, DebugInfo=152, 
+		Namespace__=153, Class__=154, Traic__=155, Function__=156, Method__=157, 
+		Line__=158, File__=159, Dir__=160, Spaceship=161, Lgeneric=162, Rgeneric=163, 
+		DoubleArrow=164, Inc=165, Dec=166, IsIdentical=167, IsNoidentical=168, 
+		IsEqual=169, IsNotEq=170, IsSmallerOrEqual=171, IsGreaterOrEqual=172, 
+		PlusEqual=173, MinusEqual=174, MulEqual=175, Pow=176, PowEqual=177, DivEqual=178, 
+		Concaequal=179, ModEqual=180, ShiftLeftEqual=181, ShiftRightEqual=182, 
+		AndEqual=183, OrEqual=184, XorEqual=185, BooleanOr=186, BooleanAnd=187, 
+		NullCoalescing=188, NullCoalescingEqual=189, ShiftLeft=190, ShiftRight=191, 
+		DoubleColon=192, ObjectOperator=193, NamespaceSeparator=194, Ellipsis=195, 
+		Less=196, Greater=197, Ampersand=198, Pipe=199, Bang=200, Caret=201, Plus=202, 
+		Minus=203, Asterisk=204, Percent=205, Divide=206, Tilde=207, SuppressWarnings=208, 
+		Dollar=209, Dot=210, QuestionMark=211, OpenRoundBracket=212, CloseRoundBracket=213, 
+		OpenSquareBracket=214, CloseSquareBracket=215, OpenCurlyBracket=216, CloseCurlyBracket=217, 
+		Comma=218, Colon=219, SemiColon=220, Eq=221, Quote=222, BackQuote=223, 
+		VarName=224, Label=225, Octal=226, Decimal=227, Real=228, Hex=229, Binary=230, 
+		BackQuoteString=231, SingleQuoteString=232, DoubleQuote=233, StartNowDoc=234, 
+		StartHereDoc=235, ErrorPhp=236, CurlyDollar=237, UnicodeEscape=238, StringPart=239, 
+		Comment=240, PHPEndSingleLineComment=241, CommentEnd=242, HereDocText=243, 
+		XmlText2=244;
+	public static final int
+		PhpComments=2, ErrorLexem=3, SkipChannel=4;
+	public static final int XML = 1;
+	public static final int INSIDE = 2;
+	public static final int HtmlQuoteStringMode = 3;
+	public static final int HtmlDoubleQuoteStringMode = 4;
+	public static final int SCRIPT = 5;
+	public static final int STYLE = 6;
+	public static final int PHP = 7;
+	public static final int InterpolationString = 8;
+	public static final int SingleLineCommentMode = 9;
+	public static final int HereDoc = 10;
+	public static String[] modeNames = {
+		"DEFAULT_MODE", "XML", "INSIDE", "HtmlQuoteStringMode", "HtmlDoubleQuoteStringMode", 
+		"SCRIPT", "STYLE", "PHP", "InterpolationString", "SingleLineCommentMode", 
+		"HereDoc"
+	};
+
+	public static final String[] ruleNames = {
+		"SeaWhitespace", "HtmlText", "XmlStart", "PHPStartEcho", "PHPStart", "HtmlScriptOpen", 
+		"HtmlStyleOpen", "HtmlComment", "HtmlDtd", "HtmlOpen", "Shebang", "NumberSign", 
+		"Error", "XmlText", "XmlClose", "XmlText2", "PHPStartEchoInside", "PHPStartInside", 
+		"HtmlClose", "HtmlSlashClose", "HtmlSlash", "HtmlEquals", "HtmlStartQuoteString", 
+		"HtmlStartDoubleQuoteString", "HtmlHex", "HtmlDecimal", "HtmlSpace", "HtmlName", 
+		"ErrorInside", "PHPStartEchoInsideQuoteString", "PHPStartInsideQuoteString", 
+		"HtmlEndQuoteString", "HtmlQuoteString", "ErrorHtmlQuote", "PHPStartEchoDoubleQuoteString", 
+		"PHPStartDoubleQuoteString", "HtmlEndDoubleQuoteString", "HtmlDoubleQuoteString", 
+		"ErrorHtmlDoubleQuote", "ScriptText", "HtmlScriptClose", "PHPStartInsideScriptEcho", 
+		"PHPStartInsideScript", "ScriptText2", "StyleBody", "PHPEnd", "Whitespace", 
+		"MultiLineComment", "SingleLineComment", "ShellStyleComment", "AttributeStart", 
+		"Abstract", "Array", "As", "BinaryCast", "BoolType", "BooleanConstant", 
+		"Break", "Callable", "Case", "Catch", "Class", "Clone", "Const", "Continue", 
+		"Declare", "Default", "Do", "DoubleCast", "DoubleType", "Echo", "Else", 
+		"ElseIf", "Empty", "Enum_", "EndDeclare", "EndFor", "EndForeach", "EndIf", 
+		"EndSwitch", "EndWhile", "Eval", "Exit", "Extends", "Final", "Finally", 
+		"FloatCast", "For", "Foreach", "Function_", "Global", "Goto", "If", "Implements", 
+		"Import", "Include", "IncludeOnce", "InstanceOf", "InsteadOf", "Int8Cast", 
+		"Int16Cast", "Int64Type", "IntType", "Interface", "IsSet", "List", "LogicalAnd", 
+		"LogicalOr", "LogicalXor", "Match_", "Namespace", "New", "Null", "ObjectType", 
+		"Parent_", "Partial", "Print", "Private", "Protected", "Public", "Readonly", 
+		"Require", "RequireOnce", "Resource", "Return", "Static", "StringType", 
+		"Switch", "Throw", "Trait", "Try", "Typeof", "UintCast", "UnicodeCast", 
+		"Unset", "Use", "Var", "While", "Yield", "From", "LambdaFn", "Ticks", 
+		"Encoding", "StrictTypes", "Get", "Set", "Call", "CallStatic", "Constructor", 
+		"Destruct", "Wakeup", "Sleep", "Autoload", "IsSet__", "Unset__", "ToString__", 
+		"Invoke", "SetState", "Clone__", "DebugInfo", "Namespace__", "Class__", 
+		"Traic__", "Function__", "Method__", "Line__", "File__", "Dir__", "Spaceship", 
+		"Lgeneric", "Rgeneric", "DoubleArrow", "Inc", "Dec", "IsIdentical", "IsNoidentical", 
+		"IsEqual", "IsNotEq", "IsSmallerOrEqual", "IsGreaterOrEqual", "PlusEqual", 
+		"MinusEqual", "MulEqual", "Pow", "PowEqual", "DivEqual", "Concaequal", 
+		"ModEqual", "ShiftLeftEqual", "ShiftRightEqual", "AndEqual", "OrEqual", 
+		"XorEqual", "BooleanOr", "BooleanAnd", "NullCoalescing", "NullCoalescingEqual", 
+		"ShiftLeft", "ShiftRight", "DoubleColon", "ObjectOperator", "NamespaceSeparator", 
+		"Ellipsis", "Less", "Greater", "Ampersand", "Pipe", "Bang", "Caret", "Plus", 
+		"Minus", "Asterisk", "Percent", "Divide", "Tilde", "SuppressWarnings", 
+		"Dollar", "Dot", "QuestionMark", "OpenRoundBracket", "CloseRoundBracket", 
+		"OpenSquareBracket", "CloseSquareBracket", "OpenCurlyBracket", "CloseCurlyBracket", 
+		"Comma", "Colon", "SemiColon", "Eq", "Quote", "BackQuote", "VarName", 
+		"Label", "Octal", "Decimal", "Real", "Hex", "Binary", "BackQuoteString", 
+		"SingleQuoteString", "DoubleQuote", "StartNowDoc", "StartHereDoc", "ErrorPhp", 
+		"VarNameInInterpolation", "DollarString", "CurlyDollar", "CurlyString", 
+		"EscapedChar", "DoubleQuoteInInterpolation", "UnicodeEscape", "StringPart", 
+		"Comment", "PHPEndSingleLineComment", "CommentQuestionMark", "CommentEnd", 
+		"HereDocText", "PhpStartEchoFragment", "PhpStartFragment", "NameString", 
+		"HtmlNameChar", "HtmlNameStartChar", "LNum", "ExponentPart", "NonZeroDigit", 
+		"Digit", "OctalDigit", "HexDigit"
+	};
+
+	private static final String[] _LITERAL_NAMES = {
+		null, null, null, "'<?xml'", null, null, null, null, null, null, null, 
+		null, null, "'?>'", null, null, "'/>'", null, null, null, null, null, 
+		null, null, null, null, null, null, null, null, null, null, null, null, 
+		null, null, null, null, null, null, null, null, null, "'#['", "'abstract'", 
+		"'array'", "'as'", "'binary'", null, null, "'break'", "'callable'", "'case'", 
+		"'catch'", "'class'", "'clone'", "'const'", "'continue'", "'declare'", 
+		"'default'", "'do'", "'real'", "'double'", "'echo'", "'else'", "'elseif'", 
+		"'empty'", "'enum'", "'enddeclare'", "'endfor'", "'endforeach'", "'endif'", 
+		"'endswitch'", "'endwhile'", "'eval'", "'die'", "'extends'", "'final'", 
+		"'finally'", "'float'", "'for'", "'foreach'", "'function'", "'global'", 
+		"'goto'", "'if'", "'implements'", "'import'", "'include'", "'include_once'", 
+		"'instanceof'", "'insteadof'", "'int8'", "'int16'", "'int64'", null, "'interface'", 
+		"'isset'", "'list'", "'and'", "'or'", "'xor'", "'match'", "'namespace'", 
+		"'new'", "'null'", "'object'", "'parent'", "'partial'", "'print'", "'private'", 
+		"'protected'", "'public'", "'readonly'", "'require'", "'require_once'", 
+		"'resource'", "'return'", "'static'", "'string'", "'switch'", "'throw'", 
+		"'trait'", "'try'", "'clrtypeof'", null, "'unicode'", "'unset'", "'use'", 
+		"'var'", "'while'", "'yield'", "'from'", "'fn'", "'ticks'", "'encoding'", 
+		"'strict_types'", "'__get'", "'__set'", "'__call'", "'__callstatic'", 
+		"'__construct'", "'__destruct'", "'__wakeup'", "'__sleep'", "'__autoload'", 
+		"'__isset'", "'__unset'", "'__tostring'", "'__invoke'", "'__set_state'", 
+		"'__clone'", "'__debuginfo'", "'__namespace__'", "'__class__'", "'__trait__'", 
+		"'__function__'", "'__method__'", "'__line__'", "'__file__'", "'__dir__'", 
+		"'<=>'", "'<:'", "':>'", "'=>'", "'++'", "'--'", "'==='", "'!=='", "'=='", 
+		null, "'<='", "'>='", "'+='", "'-='", "'*='", "'**'", "'**='", "'/='", 
+		"'.='", "'%='", "'<<='", "'>>='", "'&='", "'|='", "'^='", "'||'", "'&&'", 
+		"'??'", "'??='", "'<<'", "'>>'", "'::'", "'->'", "'\\'", "'...'", null, 
+		null, "'&'", "'|'", "'!'", "'^'", "'+'", "'-'", "'*'", "'%'", null, "'~'", 
+		"'@'", null, "'.'", null, "'('", "')'", "'['", "']'", null, "'}'", "','", 
+		"':'", "';'", null, "'''", "'`'"
+	};
+	private static final String[] _SYMBOLIC_NAMES = {
+		null, "SeaWhitespace", "HtmlText", "XmlStart", "PHPStart", "HtmlScriptOpen", 
+		"HtmlStyleOpen", "HtmlComment", "HtmlDtd", "HtmlOpen", "Shebang", "Error", 
+		"XmlText", "XmlClose", "PHPStartInside", "HtmlClose", "HtmlSlashClose", 
+		"HtmlSlash", "HtmlEquals", "HtmlStartQuoteString", "HtmlStartDoubleQuoteString", 
+		"HtmlHex", "HtmlDecimal", "HtmlSpace", "HtmlName", "ErrorInside", "PHPStartInsideQuoteString", 
+		"HtmlEndQuoteString", "HtmlQuoteString", "ErrorHtmlQuote", "PHPStartDoubleQuoteString", 
+		"HtmlEndDoubleQuoteString", "HtmlDoubleQuoteString", "ErrorHtmlDoubleQuote", 
+		"ScriptText", "HtmlScriptClose", "PHPStartInsideScript", "StyleBody", 
+		"PHPEnd", "Whitespace", "MultiLineComment", "SingleLineComment", "ShellStyleComment", 
+		"AttributeStart", "Abstract", "Array", "As", "BinaryCast", "BoolType", 
+		"BooleanConstant", "Break", "Callable", "Case", "Catch", "Class", "Clone", 
+		"Const", "Continue", "Declare", "Default", "Do", "DoubleCast", "DoubleType", 
+		"Echo", "Else", "ElseIf", "Empty", "Enum_", "EndDeclare", "EndFor", "EndForeach", 
+		"EndIf", "EndSwitch", "EndWhile", "Eval", "Exit", "Extends", "Final", 
+		"Finally", "FloatCast", "For", "Foreach", "Function_", "Global", "Goto", 
+		"If", "Implements", "Import", "Include", "IncludeOnce", "InstanceOf", 
+		"InsteadOf", "Int8Cast", "Int16Cast", "Int64Type", "IntType", "Interface", 
+		"IsSet", "List", "LogicalAnd", "LogicalOr", "LogicalXor", "Match_", "Namespace", 
+		"New", "Null", "ObjectType", "Parent_", "Partial", "Print", "Private", 
+		"Protected", "Public", "Readonly", "Require", "RequireOnce", "Resource", 
+		"Return", "Static", "StringType", "Switch", "Throw", "Trait", "Try", "Typeof", 
+		"UintCast", "UnicodeCast", "Unset", "Use", "Var", "While", "Yield", "From", 
+		"LambdaFn", "Ticks", "Encoding", "StrictTypes", "Get", "Set", "Call", 
+		"CallStatic", "Constructor", "Destruct", "Wakeup", "Sleep", "Autoload", 
+		"IsSet__", "Unset__", "ToString__", "Invoke", "SetState", "Clone__", "DebugInfo", 
+		"Namespace__", "Class__", "Traic__", "Function__", "Method__", "Line__", 
+		"File__", "Dir__", "Spaceship", "Lgeneric", "Rgeneric", "DoubleArrow", 
+		"Inc", "Dec", "IsIdentical", "IsNoidentical", "IsEqual", "IsNotEq", "IsSmallerOrEqual", 
+		"IsGreaterOrEqual", "PlusEqual", "MinusEqual", "MulEqual", "Pow", "PowEqual", 
+		"DivEqual", "Concaequal", "ModEqual", "ShiftLeftEqual", "ShiftRightEqual", 
+		"AndEqual", "OrEqual", "XorEqual", "BooleanOr", "BooleanAnd", "NullCoalescing", 
+		"NullCoalescingEqual", "ShiftLeft", "ShiftRight", "DoubleColon", "ObjectOperator", 
+		"NamespaceSeparator", "Ellipsis", "Less", "Greater", "Ampersand", "Pipe", 
+		"Bang", "Caret", "Plus", "Minus", "Asterisk", "Percent", "Divide", "Tilde", 
+		"SuppressWarnings", "Dollar", "Dot", "QuestionMark", "OpenRoundBracket", 
+		"CloseRoundBracket", "OpenSquareBracket", "CloseSquareBracket", "OpenCurlyBracket", 
+		"CloseCurlyBracket", "Comma", "Colon", "SemiColon", "Eq", "Quote", "BackQuote", 
+		"VarName", "Label", "Octal", "Decimal", "Real", "Hex", "Binary", "BackQuoteString", 
+		"SingleQuoteString", "DoubleQuote", "StartNowDoc", "StartHereDoc", "ErrorPhp", 
+		"CurlyDollar", "UnicodeEscape", "StringPart", "Comment", "PHPEndSingleLineComment", 
+		"CommentEnd", "HereDocText", "XmlText2"
+	};
+	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
+
+	/**
+	 * @deprecated Use {@link #VOCABULARY} instead.
+	 */
+	@Deprecated
+	public static final String[] tokenNames;
+	static {
+		tokenNames = new String[_SYMBOLIC_NAMES.length];
+		for (int i = 0; i < tokenNames.length; i++) {
+			tokenNames[i] = VOCABULARY.getLiteralName(i);
+			if (tokenNames[i] == null) {
+				tokenNames[i] = VOCABULARY.getSymbolicName(i);
+			}
+
+			if (tokenNames[i] == null) {
+				tokenNames[i] = "<INVALID>";
+			}
+		}
+	}
+
+	@Override
+	@Deprecated
+	public String[] getTokenNames() {
+		return tokenNames;
+	}
+
+	@Override
+
+	public Vocabulary getVocabulary() {
+		return VOCABULARY;
+	}
+
+
+	public PhpLexer(CharStream input) {
+		super(input);
+		_interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
+	}
+
+	@Override
+	public String getGrammarFileName() { return "PhpLexer.g4"; }
+
+	@Override
+	public String[] getRuleNames() { return ruleNames; }
+
+	@Override
+	public String getSerializedATN() { return _serializedATN; }
+
+	@Override
+	public String[] getModeNames() { return modeNames; }
+
+	@Override
+	public ATN getATN() { return _ATN; }
+
+	@Override
+	public void action(RuleContext _localctx, int ruleIndex, int actionIndex) {
+		switch (ruleIndex) {
+		case 5:
+			HtmlScriptOpen_action((RuleContext)_localctx, actionIndex);
+			break;
+		case 6:
+			HtmlStyleOpen_action((RuleContext)_localctx, actionIndex);
+			break;
+		case 18:
+			HtmlClose_action((RuleContext)_localctx, actionIndex);
+			break;
+		case 224:
+			CloseCurlyBracket_action((RuleContext)_localctx, actionIndex);
+			break;
+		case 246:
+			CurlyDollar_action((RuleContext)_localctx, actionIndex);
+			break;
+		}
+	}
+	private void HtmlScriptOpen_action(RuleContext _localctx, int actionIndex) {
+		switch (actionIndex) {
+		case 0:
+			 this._scriptTag = true; 
+			break;
+		}
+	}
+	private void HtmlStyleOpen_action(RuleContext _localctx, int actionIndex) {
+		switch (actionIndex) {
+		case 1:
+			 this._styleTag = true; 
+			break;
+		}
+	}
+	private void HtmlClose_action(RuleContext _localctx, int actionIndex) {
+		switch (actionIndex) {
+		case 2:
+			 this.PushModeOnHtmlClose(); 
+			break;
+		}
+	}
+	private void CloseCurlyBracket_action(RuleContext _localctx, int actionIndex) {
+		switch (actionIndex) {
+		case 3:
+			 this.PopModeOnCurlyBracketClose(); 
+			break;
+		}
+	}
+	private void CurlyDollar_action(RuleContext _localctx, int actionIndex) {
+		switch (actionIndex) {
+		case 4:
+			 this.SetInsideString(); 
+			break;
+		}
+	}
+	@Override
+	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
+		switch (ruleIndex) {
+		case 10:
+			return Shebang_sempred((RuleContext)_localctx, predIndex);
+		case 45:
+			return PHPEnd_sempred((RuleContext)_localctx, predIndex);
+		case 241:
+			return StartNowDoc_sempred((RuleContext)_localctx, predIndex);
+		case 242:
+			return StartHereDoc_sempred((RuleContext)_localctx, predIndex);
+		case 246:
+			return CurlyDollar_sempred((RuleContext)_localctx, predIndex);
+		case 257:
+			return PhpStartEchoFragment_sempred((RuleContext)_localctx, predIndex);
+		case 258:
+			return PhpStartFragment_sempred((RuleContext)_localctx, predIndex);
+		}
+		return true;
+	}
+	private boolean Shebang_sempred(RuleContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 0:
+			return  this.IsNewLineOrStart(-2) ;
+		}
+		return true;
+	}
+	private boolean PHPEnd_sempred(RuleContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 1:
+			return this.HasAspTags();
+		case 2:
+			return this.HasPhpScriptTag();
+		}
+		return true;
+	}
+	private boolean StartNowDoc_sempred(RuleContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 3:
+			return  this.ShouldPushHereDocMode(1) ;
+		}
+		return true;
+	}
+	private boolean StartHereDoc_sempred(RuleContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 4:
+			return  this.ShouldPushHereDocMode(1) ;
+		}
+		return true;
+	}
+	private boolean CurlyDollar_sempred(RuleContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 5:
+			return  this.IsCurlyDollar(1) ;
+		}
+		return true;
+	}
+	private boolean PhpStartEchoFragment_sempred(RuleContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 6:
+			return  this.HasAspTags() ;
+		}
+		return true;
+	}
+	private boolean PhpStartFragment_sempred(RuleContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 7:
+			return  this.HasAspTags() ;
+		}
+		return true;
+	}
+
+	public static final String _serializedATN =
+		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2\u00f6\u08e4\b\1\b"+
+		"\1\b\1\b\1\b\1\b\1\b\1\b\1\b\1\b\1\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5"+
+		"\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16"+
+		"\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23\4\24\t\24\4\25"+
+		"\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34"+
+		"\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4"+
+		"%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4/\t/\4\60"+
+		"\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64\4\65\t\65\4\66\t\66\4\67"+
+		"\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\t"+
+		"B\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4"+
+		"N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\tV\4W\tW\4X\tX\4Y\t"+
+		"Y\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td"+
+		"\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p"+
+		"\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4z\tz\4{\t{"+
+		"\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080\4\u0081\t\u0081\4\u0082"+
+		"\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086"+
+		"\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a\4\u008b"+
+		"\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e\t\u008e\4\u008f\t\u008f"+
+		"\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092\4\u0093\t\u0093\4\u0094"+
+		"\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098"+
+		"\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c\t\u009c\4\u009d"+
+		"\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0\t\u00a0\4\u00a1\t\u00a1"+
+		"\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6"+
+		"\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa\t\u00aa"+
+		"\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad\4\u00ae\t\u00ae\4\u00af"+
+		"\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1\4\u00b2\t\u00b2\4\u00b3\t\u00b3"+
+		"\4\u00b4\t\u00b4\4\u00b5\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8"+
+		"\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb\4\u00bc\t\u00bc"+
+		"\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf\4\u00c0\t\u00c0\4\u00c1"+
+		"\t\u00c1\4\u00c2\t\u00c2\4\u00c3\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5"+
+		"\4\u00c6\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9\4\u00ca"+
+		"\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd\t\u00cd\4\u00ce\t\u00ce"+
+		"\4\u00cf\t\u00cf\4\u00d0\t\u00d0\4\u00d1\t\u00d1\4\u00d2\t\u00d2\4\u00d3"+
+		"\t\u00d3\4\u00d4\t\u00d4\4\u00d5\t\u00d5\4\u00d6\t\u00d6\4\u00d7\t\u00d7"+
+		"\4\u00d8\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da\4\u00db\t\u00db\4\u00dc"+
+		"\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de\4\u00df\t\u00df\4\u00e0\t\u00e0"+
+		"\4\u00e1\t\u00e1\4\u00e2\t\u00e2\4\u00e3\t\u00e3\4\u00e4\t\u00e4\4\u00e5"+
+		"\t\u00e5\4\u00e6\t\u00e6\4\u00e7\t\u00e7\4\u00e8\t\u00e8\4\u00e9\t\u00e9"+
+		"\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec\4\u00ed\t\u00ed\4\u00ee"+
+		"\t\u00ee\4\u00ef\t\u00ef\4\u00f0\t\u00f0\4\u00f1\t\u00f1\4\u00f2\t\u00f2"+
+		"\4\u00f3\t\u00f3\4\u00f4\t\u00f4\4\u00f5\t\u00f5\4\u00f6\t\u00f6\4\u00f7"+
+		"\t\u00f7\4\u00f8\t\u00f8\4\u00f9\t\u00f9\4\u00fa\t\u00fa\4\u00fb\t\u00fb"+
+		"\4\u00fc\t\u00fc\4\u00fd\t\u00fd\4\u00fe\t\u00fe\4\u00ff\t\u00ff\4\u0100"+
+		"\t\u0100\4\u0101\t\u0101\4\u0102\t\u0102\4\u0103\t\u0103\4\u0104\t\u0104"+
+		"\4\u0105\t\u0105\4\u0106\t\u0106\4\u0107\t\u0107\4\u0108\t\u0108\4\u0109"+
+		"\t\u0109\4\u010a\t\u010a\4\u010b\t\u010b\4\u010c\t\u010c\4\u010d\t\u010d"+
+		"\3\2\6\2\u0227\n\2\r\2\16\2\u0228\3\2\3\2\3\3\6\3\u022e\n\3\r\3\16\3\u022f"+
+		"\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3"+
+		"\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b"+
+		"\3\b\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\7\t\u0262\n\t\f\t"+
+		"\16\t\u0265\13\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\7\n\u0271\n\n"+
+		"\f\n\16\n\u0274\13\n\3\n\3\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\7\f\u0280"+
+		"\n\f\f\f\16\f\u0283\13\f\3\r\3\r\7\r\u0287\n\r\f\r\16\r\u028a\13\r\3\r"+
+		"\3\r\3\16\3\16\3\16\3\16\3\17\6\17\u0293\n\17\r\17\16\17\u0294\3\20\3"+
+		"\20\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\3\23\3"+
+		"\23\3\23\3\23\3\23\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3"+
+		"\27\3\27\3\30\5\30\u02b7\n\30\3\30\3\30\3\30\3\30\3\31\5\31\u02be\n\31"+
+		"\3\31\3\31\3\31\3\31\3\32\3\32\6\32\u02c6\n\32\r\32\16\32\u02c7\3\33\6"+
+		"\33\u02cb\n\33\r\33\16\33\u02cc\3\34\6\34\u02d0\n\34\r\34\16\34\u02d1"+
+		"\3\34\3\34\3\35\3\35\7\35\u02d8\n\35\f\35\16\35\u02db\13\35\3\36\3\36"+
+		"\3\36\3\36\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3 \3!\3!\5!\u02ed\n!\3"+
+		"!\3!\3\"\6\"\u02f2\n\"\r\"\16\"\u02f3\3#\3#\3#\3#\3$\3$\3$\3$\3$\3%\3"+
+		"%\3%\3%\3%\3&\3&\5&\u0306\n&\3&\3&\3\'\6\'\u030b\n\'\r\'\16\'\u030c\3"+
+		"(\3(\3(\3(\3)\6)\u0314\n)\r)\16)\u0315\3*\3*\3*\3*\3*\3*\3*\3*\3*\5*\u0321"+
+		"\n*\3*\3*\3*\3*\3+\3+\3+\3+\3+\3,\3,\3,\3,\3,\3-\3-\3-\3-\3.\7.\u0336"+
+		"\n.\f.\16.\u0339\13.\3.\3.\3.\3.\3.\3.\3.\3.\5.\u0343\n.\3.\3.\3.\3.\3"+
+		"/\3/\3/\5/\u034c\n/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\5/\u035a\n/\3"+
+		"\60\6\60\u035d\n\60\r\60\16\60\u035e\3\60\3\60\3\61\3\61\3\61\3\61\7\61"+
+		"\u0367\n\61\f\61\16\61\u036a\13\61\3\61\3\61\3\61\3\61\3\61\3\62\3\62"+
+		"\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3\65\3\65"+
+		"\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\66\3\66\3\66\3\66\3\66\3\66\3\67"+
+		"\3\67\3\67\38\38\38\38\38\38\38\39\39\39\39\39\39\39\39\59\u03a0\n9\3"+
+		":\3:\3:\3:\3:\3:\3:\3:\3:\5:\u03ab\n:\3;\3;\3;\3;\3;\3;\3<\3<\3<\3<\3"+
+		"<\3<\3<\3<\3<\3=\3=\3=\3=\3=\3>\3>\3>\3>\3>\3>\3?\3?\3?\3?\3?\3?\3@\3"+
+		"@\3@\3@\3@\3@\3A\3A\3A\3A\3A\3A\3B\3B\3B\3B\3B\3B\3B\3B\3B\3C\3C\3C\3"+
+		"C\3C\3C\3C\3C\3D\3D\3D\3D\3D\3D\3D\3D\3E\3E\3E\3F\3F\3F\3F\3F\3G\3G\3"+
+		"G\3G\3G\3G\3G\3H\3H\3H\3H\3H\3I\3I\3I\3I\3I\3J\3J\3J\3J\3J\3J\3J\3K\3"+
+		"K\3K\3K\3K\3K\3L\3L\3L\3L\3L\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3N\3N\3"+
+		"N\3N\3N\3N\3N\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3P\3P\3P\3P\3P\3P\3Q\3"+
+		"Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3R\3R\3R\3R\3R\3R\3R\3R\3R\3S\3S\3S\3S\3S\3"+
+		"T\3T\3T\3T\3U\3U\3U\3U\3U\3U\3U\3U\3V\3V\3V\3V\3V\3V\3W\3W\3W\3W\3W\3"+
+		"W\3W\3W\3X\3X\3X\3X\3X\3X\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3[\3[\3"+
+		"[\3[\3[\3[\3[\3[\3[\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3]\3]\3]\3]\3]\3^\3^\3"+
+		"^\3_\3_\3_\3_\3_\3_\3_\3_\3_\3_\3_\3`\3`\3`\3`\3`\3`\3`\3a\3a\3a\3a\3"+
+		"a\3a\3a\3a\3b\3b\3b\3b\3b\3b\3b\3b\3b\3b\3b\3b\3b\3c\3c\3c\3c\3c\3c\3"+
+		"c\3c\3c\3c\3c\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3e\3e\3e\3e\3e\3f\3f\3f\3"+
+		"f\3f\3f\3g\3g\3g\3g\3g\3g\3h\3h\3h\3h\3h\3h\3h\3h\5h\u04f1\nh\3i\3i\3"+
+		"i\3i\3i\3i\3i\3i\3i\3i\3j\3j\3j\3j\3j\3j\3k\3k\3k\3k\3k\3l\3l\3l\3l\3"+
+		"m\3m\3m\3n\3n\3n\3n\3o\3o\3o\3o\3o\3o\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\3"+
+		"q\3q\3q\3q\3r\3r\3r\3r\3r\3s\3s\3s\3s\3s\3s\3s\3t\3t\3t\3t\3t\3t\3t\3"+
+		"u\3u\3u\3u\3u\3u\3u\3u\3v\3v\3v\3v\3v\3v\3w\3w\3w\3w\3w\3w\3w\3w\3x\3"+
+		"x\3x\3x\3x\3x\3x\3x\3x\3x\3y\3y\3y\3y\3y\3y\3y\3z\3z\3z\3z\3z\3z\3z\3"+
+		"z\3z\3{\3{\3{\3{\3{\3{\3{\3{\3|\3|\3|\3|\3|\3|\3|\3|\3|\3|\3|\3|\3|\3"+
+		"}\3}\3}\3}\3}\3}\3}\3}\3}\3~\3~\3~\3~\3~\3~\3~\3\177\3\177\3\177\3\177"+
+		"\3\177\3\177\3\177\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080"+
+		"\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0082\3\u0082"+
+		"\3\u0082\3\u0082\3\u0082\3\u0082\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083"+
+		"\3\u0083\3\u0084\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085\3\u0085\3\u0085"+
+		"\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\3\u0086\3\u0086\3\u0086"+
+		"\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\5\u0086\u05c8"+
+		"\n\u0086\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087"+
+		"\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089"+
+		"\3\u0089\3\u008a\3\u008a\3\u008a\3\u008a\3\u008b\3\u008b\3\u008b\3\u008b"+
+		"\3\u008b\3\u008b\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008c\3\u008d"+
+		"\3\u008d\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e\3\u008f\3\u008f"+
+		"\3\u008f\3\u008f\3\u008f\3\u008f\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090"+
+		"\3\u0090\3\u0090\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091"+
+		"\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0092"+
+		"\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0093\3\u0093\3\u0093\3\u0093"+
+		"\3\u0093\3\u0093\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094"+
+		"\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095"+
+		"\3\u0095\3\u0095\3\u0095\3\u0095\3\u0096\3\u0096\3\u0096\3\u0096\3\u0096"+
+		"\3\u0096\3\u0096\3\u0096\3\u0096\3\u0096\3\u0096\3\u0096\3\u0097\3\u0097"+
+		"\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097"+
+		"\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098"+
+		"\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u009a"+
+		"\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a"+
+		"\3\u009a\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b"+
+		"\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009d"+
+		"\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d"+
+		"\3\u009d\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e"+
+		"\3\u009e\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f"+
+		"\3\u009f\3\u009f\3\u009f\3\u009f\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0"+
+		"\3\u00a0\3\u00a0\3\u00a0\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1"+
+		"\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a2"+
+		"\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2"+
+		"\3\u00a2\3\u00a2\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3"+
+		"\3\u00a3\3\u00a3\3\u00a3\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4"+
+		"\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5"+
+		"\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a6"+
+		"\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6"+
+		"\3\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7"+
+		"\3\u00a7\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8"+
+		"\3\u00a8\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9"+
+		"\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ab\3\u00ac\3\u00ac"+
+		"\3\u00ac\3\u00ad\3\u00ad\3\u00ad\3\u00ae\3\u00ae\3\u00ae\3\u00af\3\u00af"+
+		"\3\u00af\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b1\3\u00b1\3\u00b1\3\u00b1"+
+		"\3\u00b2\3\u00b2\3\u00b2\3\u00b3\3\u00b3\3\u00b3\3\u00b3\5\u00b3\u071d"+
+		"\n\u00b3\3\u00b4\3\u00b4\3\u00b4\3\u00b5\3\u00b5\3\u00b5\3\u00b6\3\u00b6"+
+		"\3\u00b6\3\u00b7\3\u00b7\3\u00b7\3\u00b8\3\u00b8\3\u00b8\3\u00b9\3\u00b9"+
+		"\3\u00b9\3\u00ba\3\u00ba\3\u00ba\3\u00ba\3\u00bb\3\u00bb\3\u00bb\3\u00bc"+
+		"\3\u00bc\3\u00bc\3\u00bd\3\u00bd\3\u00bd\3\u00be\3\u00be\3\u00be\3\u00be"+
+		"\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00c0\3\u00c0\3\u00c0\3\u00c1\3\u00c1"+
+		"\3\u00c1\3\u00c2\3\u00c2\3\u00c2\3\u00c3\3\u00c3\3\u00c3\3\u00c4\3\u00c4"+
+		"\3\u00c4\3\u00c5\3\u00c5\3\u00c5\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c7"+
+		"\3\u00c7\3\u00c7\3\u00c8\3\u00c8\3\u00c8\3\u00c9\3\u00c9\3\u00c9\3\u00ca"+
+		"\3\u00ca\3\u00ca\3\u00cb\3\u00cb\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cd"+
+		"\3\u00cd\3\u00ce\3\u00ce\3\u00cf\3\u00cf\3\u00d0\3\u00d0\3\u00d1\3\u00d1"+
+		"\3\u00d2\3\u00d2\3\u00d3\3\u00d3\3\u00d4\3\u00d4\3\u00d5\3\u00d5\3\u00d6"+
+		"\3\u00d6\3\u00d7\3\u00d7\3\u00d8\3\u00d8\3\u00d9\3\u00d9\3\u00da\3\u00da"+
+		"\3\u00db\3\u00db\3\u00dc\3\u00dc\3\u00dd\3\u00dd\3\u00de\3\u00de\3\u00df"+
+		"\3\u00df\3\u00e0\3\u00e0\3\u00e1\3\u00e1\3\u00e2\3\u00e2\3\u00e2\3\u00e3"+
+		"\3\u00e3\3\u00e4\3\u00e4\3\u00e5\3\u00e5\3\u00e6\3\u00e6\3\u00e7\3\u00e7"+
+		"\3\u00e8\3\u00e8\3\u00e9\3\u00e9\3\u00e9\3\u00ea\3\u00ea\7\u00ea\u07ac"+
+		"\n\u00ea\f\u00ea\16\u00ea\u07af\13\u00ea\3\u00eb\3\u00eb\5\u00eb\u07b3"+
+		"\n\u00eb\3\u00eb\6\u00eb\u07b6\n\u00eb\r\u00eb\16\u00eb\u07b7\3\u00eb"+
+		"\3\u00eb\6\u00eb\u07bc\n\u00eb\r\u00eb\16\u00eb\u07bd\7\u00eb\u07c0\n"+
+		"\u00eb\f\u00eb\16\u00eb\u07c3\13\u00eb\3\u00ec\3\u00ec\3\u00ec\7\u00ec"+
+		"\u07c8\n\u00ec\f\u00ec\16\u00ec\u07cb\13\u00ec\3\u00ec\3\u00ec\6\u00ec"+
+		"\u07cf\n\u00ec\r\u00ec\16\u00ec\u07d0\7\u00ec\u07d3\n\u00ec\f\u00ec\16"+
+		"\u00ec\u07d6\13\u00ec\5\u00ec\u07d8\n\u00ec\3\u00ed\3\u00ed\3\u00ed\5"+
+		"\u00ed\u07dd\n\u00ed\3\u00ed\5\u00ed\u07e0\n\u00ed\3\u00ed\3\u00ed\5\u00ed"+
+		"\u07e4\n\u00ed\3\u00ed\5\u00ed\u07e7\n\u00ed\3\u00ed\6\u00ed\u07ea\n\u00ed"+
+		"\r\u00ed\16\u00ed\u07eb\3\u00ed\3\u00ed\5\u00ed\u07f0\n\u00ed\3\u00ee"+
+		"\3\u00ee\3\u00ee\3\u00ee\6\u00ee\u07f6\n\u00ee\r\u00ee\16\u00ee\u07f7"+
+		"\3\u00ee\3\u00ee\6\u00ee\u07fc\n\u00ee\r\u00ee\16\u00ee\u07fd\7\u00ee"+
+		"\u0800\n\u00ee\f\u00ee\16\u00ee\u0803\13\u00ee\3\u00ef\3\u00ef\3\u00ef"+
+		"\3\u00ef\6\u00ef\u0809\n\u00ef\r\u00ef\16\u00ef\u080a\3\u00ef\3\u00ef"+
+		"\6\u00ef\u080f\n\u00ef\r\u00ef\16\u00ef\u0810\7\u00ef\u0813\n\u00ef\f"+
+		"\u00ef\16\u00ef\u0816\13\u00ef\3\u00f0\3\u00f0\7\u00f0\u081a\n\u00f0\f"+
+		"\u00f0\16\u00f0\u081d\13\u00f0\3\u00f0\3\u00f0\3\u00f1\3\u00f1\3\u00f1"+
+		"\3\u00f1\7\u00f1\u0825\n\u00f1\f\u00f1\16\u00f1\u0828\13\u00f1\3\u00f1"+
+		"\3\u00f1\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f3\3\u00f3\3\u00f3\3\u00f3"+
+		"\3\u00f3\7\u00f3\u0835\n\u00f3\f\u00f3\16\u00f3\u0838\13\u00f3\3\u00f3"+
+		"\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f4\3\u00f4\3\u00f4"+
+		"\3\u00f4\3\u00f4\7\u00f4\u0846\n\u00f4\f\u00f4\16\u00f4\u0849\13\u00f4"+
+		"\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f5\3\u00f5\3\u00f5\3\u00f5"+
+		"\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f6\3\u00f7\3\u00f7\3\u00f7\3\u00f7"+
+		"\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f8\3\u00f9\3\u00f9"+
+		"\3\u00f9\3\u00f9\3\u00fa\3\u00fa\3\u00fa\3\u00fa\3\u00fa\3\u00fb\3\u00fb"+
+		"\3\u00fb\3\u00fb\3\u00fb\3\u00fc\3\u00fc\3\u00fc\3\u00fc\3\u00fc\3\u00fc"+
+		"\6\u00fc\u0878\n\u00fc\r\u00fc\16\u00fc\u0879\3\u00fc\3\u00fc\3\u00fd"+
+		"\6\u00fd\u087f\n\u00fd\r\u00fd\16\u00fd\u0880\3\u00fe\6\u00fe\u0884\n"+
+		"\u00fe\r\u00fe\16\u00fe\u0885\3\u00fe\3\u00fe\3\u00ff\3\u00ff\3\u00ff"+
+		"\3\u0100\3\u0100\3\u0100\3\u0100\3\u0100\3\u0101\3\u0101\3\u0101\3\u0101"+
+		"\3\u0101\3\u0102\7\u0102\u0898\n\u0102\f\u0102\16\u0102\u089b\13\u0102"+
+		"\3\u0102\5\u0102\u089e\n\u0102\3\u0102\3\u0102\5\u0102\u08a2\n\u0102\3"+
+		"\u0103\3\u0103\3\u0103\3\u0103\3\u0103\3\u0103\5\u0103\u08aa\n\u0103\3"+
+		"\u0104\3\u0104\3\u0104\3\u0104\3\u0104\5\u0104\u08b1\n\u0104\3\u0104\3"+
+		"\u0104\5\u0104\u08b5\n\u0104\3\u0105\3\u0105\7\u0105\u08b9\n\u0105\f\u0105"+
+		"\16\u0105\u08bc\13\u0105\3\u0106\3\u0106\3\u0106\3\u0106\5\u0106\u08c2"+
+		"\n\u0106\3\u0107\5\u0107\u08c5\n\u0107\3\u0108\6\u0108\u08c8\n\u0108\r"+
+		"\u0108\16\u0108\u08c9\3\u0108\3\u0108\6\u0108\u08ce\n\u0108\r\u0108\16"+
+		"\u0108\u08cf\7\u0108\u08d2\n\u0108\f\u0108\16\u0108\u08d5\13\u0108\3\u0109"+
+		"\3\u0109\5\u0109\u08d9\n\u0109\3\u0109\3\u0109\3\u010a\3\u010a\3\u010b"+
+		"\3\u010b\3\u010c\3\u010c\3\u010d\3\u010d\7\u0263\u0272\u0337\u0368\u0899"+
+		"\2\u010e\r\3\17\4\21\5\23\2\25\6\27\7\31\b\33\t\35\n\37\13!\f#\2%\r\'"+
+		"\16)\17+\u00f6-\2/\20\61\21\63\22\65\23\67\249\25;\26=\27?\30A\31C\32"+
+		"E\33G\2I\34K\35M\36O\37Q\2S U!W\"Y#[$]%_\2a&c\2e\'g(i)k*m+o,q-s.u/w\60"+
+		"y\61{\62}\63\177\64\u0081\65\u0083\66\u0085\67\u00878\u00899\u008b:\u008d"+
+		";\u008f<\u0091=\u0093>\u0095?\u0097@\u0099A\u009bB\u009dC\u009fD\u00a1"+
+		"E\u00a3F\u00a5G\u00a7H\u00a9I\u00abJ\u00adK\u00afL\u00b1M\u00b3N\u00b5"+
+		"O\u00b7P\u00b9Q\u00bbR\u00bdS\u00bfT\u00c1U\u00c3V\u00c5W\u00c7X\u00c9"+
+		"Y\u00cbZ\u00cd[\u00cf\\\u00d1]\u00d3^\u00d5_\u00d7`\u00d9a\u00dbb\u00dd"+
+		"c\u00dfd\u00e1e\u00e3f\u00e5g\u00e7h\u00e9i\u00ebj\u00edk\u00efl\u00f1"+
+		"m\u00f3n\u00f5o\u00f7p\u00f9q\u00fbr\u00fds\u00fft\u0101u\u0103v\u0105"+
+		"w\u0107x\u0109y\u010bz\u010d{\u010f|\u0111}\u0113~\u0115\177\u0117\u0080"+
+		"\u0119\u0081\u011b\u0082\u011d\u0083\u011f\u0084\u0121\u0085\u0123\u0086"+
+		"\u0125\u0087\u0127\u0088\u0129\u0089\u012b\u008a\u012d\u008b\u012f\u008c"+
+		"\u0131\u008d\u0133\u008e\u0135\u008f\u0137\u0090\u0139\u0091\u013b\u0092"+
+		"\u013d\u0093\u013f\u0094\u0141\u0095\u0143\u0096\u0145\u0097\u0147\u0098"+
+		"\u0149\u0099\u014b\u009a\u014d\u009b\u014f\u009c\u0151\u009d\u0153\u009e"+
+		"\u0155\u009f\u0157\u00a0\u0159\u00a1\u015b\u00a2\u015d\u00a3\u015f\u00a4"+
+		"\u0161\u00a5\u0163\u00a6\u0165\u00a7\u0167\u00a8\u0169\u00a9\u016b\u00aa"+
+		"\u016d\u00ab\u016f\u00ac\u0171\u00ad\u0173\u00ae\u0175\u00af\u0177\u00b0"+
+		"\u0179\u00b1\u017b\u00b2\u017d\u00b3\u017f\u00b4\u0181\u00b5\u0183\u00b6"+
+		"\u0185\u00b7\u0187\u00b8\u0189\u00b9\u018b\u00ba\u018d\u00bb\u018f\u00bc"+
+		"\u0191\u00bd\u0193\u00be\u0195\u00bf\u0197\u00c0\u0199\u00c1\u019b\u00c2"+
+		"\u019d\u00c3\u019f\u00c4\u01a1\u00c5\u01a3\u00c6\u01a5\u00c7\u01a7\u00c8"+
+		"\u01a9\u00c9\u01ab\u00ca\u01ad\u00cb\u01af\u00cc\u01b1\u00cd\u01b3\u00ce"+
+		"\u01b5\u00cf\u01b7\u00d0\u01b9\u00d1\u01bb\u00d2\u01bd\u00d3\u01bf\u00d4"+
+		"\u01c1\u00d5\u01c3\u00d6\u01c5\u00d7\u01c7\u00d8\u01c9\u00d9\u01cb\u00da"+
+		"\u01cd\u00db\u01cf\u00dc\u01d1\u00dd\u01d3\u00de\u01d5\u00df\u01d7\u00e0"+
+		"\u01d9\u00e1\u01db\u00e2\u01dd\u00e3\u01df\u00e4\u01e1\u00e5\u01e3\u00e6"+
+		"\u01e5\u00e7\u01e7\u00e8\u01e9\u00e9\u01eb\u00ea\u01ed\u00eb\u01ef\u00ec"+
+		"\u01f1\u00ed\u01f3\u00ee\u01f5\2\u01f7\2\u01f9\u00ef\u01fb\2\u01fd\2\u01ff"+
+		"\2\u0201\u00f0\u0203\u00f1\u0205\u00f2\u0207\u00f3\u0209\2\u020b\u00f4"+
+		"\u020d\u00f5\u020f\2\u0211\2\u0213\2\u0215\2\u0217\2\u0219\2\u021b\2\u021d"+
+		"\2\u021f\2\u0221\2\u0223\2\r\2\3\4\5\6\7\b\t\n\13\f\34\5\2\13\f\17\17"+
+		"\"\"\4\2%%>>\4\2\f\f\17\17\3\2>>\3\2AA\4\2))>>\4\2$$>>\4\2aac|\5\2\62"+
+		";aac|\3\2\62\63\3\2bb\4\2))^^\4\2\13\13\"\"\4\2\62;c|\6\2$$&&^^}}\5\2"+
+		"\f\f\17\17AA\6\2C\\aac|\u0082\0\7\2\62;C\\aac|\u0082\0\4\2/\60aa\5\2\u00b9"+
+		"\u00b9\u0302\u0371\u2041\u2042\n\2<<C\\c|\u2072\u2191\u2c02\u2ff1\u3003"+
+		"\ud801\uf902\ufdd1\ufdf2\uffff\4\2--//\3\2\63;\3\2\62;\3\2\629\4\2\62"+
+		";ch\u0919\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2"+
+		"\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2"+
+		"\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\3\'\3\2\2\2\3)\3\2\2\2\3+\3\2\2\2\4"+
+		"-\3\2\2\2\4/\3\2\2\2\4\61\3\2\2\2\4\63\3\2\2\2\4\65\3\2\2\2\4\67\3\2\2"+
+		"\2\49\3\2\2\2\4;\3\2\2\2\4=\3\2\2\2\4?\3\2\2\2\4A\3\2\2\2\4C\3\2\2\2\4"+
+		"E\3\2\2\2\5G\3\2\2\2\5I\3\2\2\2\5K\3\2\2\2\5M\3\2\2\2\5O\3\2\2\2\6Q\3"+
+		"\2\2\2\6S\3\2\2\2\6U\3\2\2\2\6W\3\2\2\2\6Y\3\2\2\2\7[\3\2\2\2\7]\3\2\2"+
+		"\2\7_\3\2\2\2\7a\3\2\2\2\7c\3\2\2\2\be\3\2\2\2\tg\3\2\2\2\ti\3\2\2\2\t"+
+		"k\3\2\2\2\tm\3\2\2\2\to\3\2\2\2\tq\3\2\2\2\ts\3\2\2\2\tu\3\2\2\2\tw\3"+
+		"\2\2\2\ty\3\2\2\2\t{\3\2\2\2\t}\3\2\2\2\t\177\3\2\2\2\t\u0081\3\2\2\2"+
+		"\t\u0083\3\2\2\2\t\u0085\3\2\2\2\t\u0087\3\2\2\2\t\u0089\3\2\2\2\t\u008b"+
+		"\3\2\2\2\t\u008d\3\2\2\2\t\u008f\3\2\2\2\t\u0091\3\2\2\2\t\u0093\3\2\2"+
+		"\2\t\u0095\3\2\2\2\t\u0097\3\2\2\2\t\u0099\3\2\2\2\t\u009b\3\2\2\2\t\u009d"+
+		"\3\2\2\2\t\u009f\3\2\2\2\t\u00a1\3\2\2\2\t\u00a3\3\2\2\2\t\u00a5\3\2\2"+
+		"\2\t\u00a7\3\2\2\2\t\u00a9\3\2\2\2\t\u00ab\3\2\2\2\t\u00ad\3\2\2\2\t\u00af"+
+		"\3\2\2\2\t\u00b1\3\2\2\2\t\u00b3\3\2\2\2\t\u00b5\3\2\2\2\t\u00b7\3\2\2"+
+		"\2\t\u00b9\3\2\2\2\t\u00bb\3\2\2\2\t\u00bd\3\2\2\2\t\u00bf\3\2\2\2\t\u00c1"+
+		"\3\2\2\2\t\u00c3\3\2\2\2\t\u00c5\3\2\2\2\t\u00c7\3\2\2\2\t\u00c9\3\2\2"+
+		"\2\t\u00cb\3\2\2\2\t\u00cd\3\2\2\2\t\u00cf\3\2\2\2\t\u00d1\3\2\2\2\t\u00d3"+
+		"\3\2\2\2\t\u00d5\3\2\2\2\t\u00d7\3\2\2\2\t\u00d9\3\2\2\2\t\u00db\3\2\2"+
+		"\2\t\u00dd\3\2\2\2\t\u00df\3\2\2\2\t\u00e1\3\2\2\2\t\u00e3\3\2\2\2\t\u00e5"+
+		"\3\2\2\2\t\u00e7\3\2\2\2\t\u00e9\3\2\2\2\t\u00eb\3\2\2\2\t\u00ed\3\2\2"+
+		"\2\t\u00ef\3\2\2\2\t\u00f1\3\2\2\2\t\u00f3\3\2\2\2\t\u00f5\3\2\2\2\t\u00f7"+
+		"\3\2\2\2\t\u00f9\3\2\2\2\t\u00fb\3\2\2\2\t\u00fd\3\2\2\2\t\u00ff\3\2\2"+
+		"\2\t\u0101\3\2\2\2\t\u0103\3\2\2\2\t\u0105\3\2\2\2\t\u0107\3\2\2\2\t\u0109"+
+		"\3\2\2\2\t\u010b\3\2\2\2\t\u010d\3\2\2\2\t\u010f\3\2\2\2\t\u0111\3\2\2"+
+		"\2\t\u0113\3\2\2\2\t\u0115\3\2\2\2\t\u0117\3\2\2\2\t\u0119\3\2\2\2\t\u011b"+
+		"\3\2\2\2\t\u011d\3\2\2\2\t\u011f\3\2\2\2\t\u0121\3\2\2\2\t\u0123\3\2\2"+
+		"\2\t\u0125\3\2\2\2\t\u0127\3\2\2\2\t\u0129\3\2\2\2\t\u012b\3\2\2\2\t\u012d"+
+		"\3\2\2\2\t\u012f\3\2\2\2\t\u0131\3\2\2\2\t\u0133\3\2\2\2\t\u0135\3\2\2"+
+		"\2\t\u0137\3\2\2\2\t\u0139\3\2\2\2\t\u013b\3\2\2\2\t\u013d\3\2\2\2\t\u013f"+
+		"\3\2\2\2\t\u0141\3\2\2\2\t\u0143\3\2\2\2\t\u0145\3\2\2\2\t\u0147\3\2\2"+
+		"\2\t\u0149\3\2\2\2\t\u014b\3\2\2\2\t\u014d\3\2\2\2\t\u014f\3\2\2\2\t\u0151"+
+		"\3\2\2\2\t\u0153\3\2\2\2\t\u0155\3\2\2\2\t\u0157\3\2\2\2\t\u0159\3\2\2"+
+		"\2\t\u015b\3\2\2\2\t\u015d\3\2\2\2\t\u015f\3\2\2\2\t\u0161\3\2\2\2\t\u0163"+
+		"\3\2\2\2\t\u0165\3\2\2\2\t\u0167\3\2\2\2\t\u0169\3\2\2\2\t\u016b\3\2\2"+
+		"\2\t\u016d\3\2\2\2\t\u016f\3\2\2\2\t\u0171\3\2\2\2\t\u0173\3\2\2\2\t\u0175"+
+		"\3\2\2\2\t\u0177\3\2\2\2\t\u0179\3\2\2\2\t\u017b\3\2\2\2\t\u017d\3\2\2"+
+		"\2\t\u017f\3\2\2\2\t\u0181\3\2\2\2\t\u0183\3\2\2\2\t\u0185\3\2\2\2\t\u0187"+
+		"\3\2\2\2\t\u0189\3\2\2\2\t\u018b\3\2\2\2\t\u018d\3\2\2\2\t\u018f\3\2\2"+
+		"\2\t\u0191\3\2\2\2\t\u0193\3\2\2\2\t\u0195\3\2\2\2\t\u0197\3\2\2\2\t\u0199"+
+		"\3\2\2\2\t\u019b\3\2\2\2\t\u019d\3\2\2\2\t\u019f\3\2\2\2\t\u01a1\3\2\2"+
+		"\2\t\u01a3\3\2\2\2\t\u01a5\3\2\2\2\t\u01a7\3\2\2\2\t\u01a9\3\2\2\2\t\u01ab"+
+		"\3\2\2\2\t\u01ad\3\2\2\2\t\u01af\3\2\2\2\t\u01b1\3\2\2\2\t\u01b3\3\2\2"+
+		"\2\t\u01b5\3\2\2\2\t\u01b7\3\2\2\2\t\u01b9\3\2\2\2\t\u01bb\3\2\2\2\t\u01bd"+
+		"\3\2\2\2\t\u01bf\3\2\2\2\t\u01c1\3\2\2\2\t\u01c3\3\2\2\2\t\u01c5\3\2\2"+
+		"\2\t\u01c7\3\2\2\2\t\u01c9\3\2\2\2\t\u01cb\3\2\2\2\t\u01cd\3\2\2\2\t\u01cf"+
+		"\3\2\2\2\t\u01d1\3\2\2\2\t\u01d3\3\2\2\2\t\u01d5\3\2\2\2\t\u01d7\3\2\2"+
+		"\2\t\u01d9\3\2\2\2\t\u01db\3\2\2\2\t\u01dd\3\2\2\2\t\u01df\3\2\2\2\t\u01e1"+
+		"\3\2\2\2\t\u01e3\3\2\2\2\t\u01e5\3\2\2\2\t\u01e7\3\2\2\2\t\u01e9\3\2\2"+
+		"\2\t\u01eb\3\2\2\2\t\u01ed\3\2\2\2\t\u01ef\3\2\2\2\t\u01f1\3\2\2\2\t\u01f3"+
+		"\3\2\2\2\n\u01f5\3\2\2\2\n\u01f7\3\2\2\2\n\u01f9\3\2\2\2\n\u01fb\3\2\2"+
+		"\2\n\u01fd\3\2\2\2\n\u01ff\3\2\2\2\n\u0201\3\2\2\2\n\u0203\3\2\2\2\13"+
+		"\u0205\3\2\2\2\13\u0207\3\2\2\2\13\u0209\3\2\2\2\13\u020b\3\2\2\2\f\u020d"+
+		"\3\2\2\2\r\u0226\3\2\2\2\17\u022d\3\2\2\2\21\u0231\3\2\2\2\23\u0239\3"+
+		"\2\2\2\25\u023e\3\2\2\2\27\u0243\3\2\2\2\31\u024f\3\2\2\2\33\u025a\3\2"+
+		"\2\2\35\u026c\3\2\2\2\37\u0277\3\2\2\2!\u027b\3\2\2\2#\u0284\3\2\2\2%"+
+		"\u028d\3\2\2\2\'\u0292\3\2\2\2)\u0296\3\2\2\2+\u029b\3\2\2\2-\u029f\3"+
+		"\2\2\2/\u02a4\3\2\2\2\61\u02a9\3\2\2\2\63\u02ac\3\2\2\2\65\u02b1\3\2\2"+
+		"\2\67\u02b3\3\2\2\29\u02b6\3\2\2\2;\u02bd\3\2\2\2=\u02c3\3\2\2\2?\u02ca"+
+		"\3\2\2\2A\u02cf\3\2\2\2C\u02d5\3\2\2\2E\u02dc\3\2\2\2G\u02e0\3\2\2\2I"+
+		"\u02e5\3\2\2\2K\u02ea\3\2\2\2M\u02f1\3\2\2\2O\u02f5\3\2\2\2Q\u02f9\3\2"+
+		"\2\2S\u02fe\3\2\2\2U\u0303\3\2\2\2W\u030a\3\2\2\2Y\u030e\3\2\2\2[\u0313"+
+		"\3\2\2\2]\u0317\3\2\2\2_\u0326\3\2\2\2a\u032b\3\2\2\2c\u0330\3\2\2\2e"+
+		"\u0337\3\2\2\2g\u0359\3\2\2\2i\u035c\3\2\2\2k\u0362\3\2\2\2m\u0370\3\2"+
+		"\2\2o\u0376\3\2\2\2q\u037b\3\2\2\2s\u037e\3\2\2\2u\u0387\3\2\2\2w\u038d"+
+		"\3\2\2\2y\u0390\3\2\2\2{\u0397\3\2\2\2}\u03aa\3\2\2\2\177\u03ac\3\2\2"+
+		"\2\u0081\u03b2\3\2\2\2\u0083\u03bb\3\2\2\2\u0085\u03c0\3\2\2\2\u0087\u03c6"+
+		"\3\2\2\2\u0089\u03cc\3\2\2\2\u008b\u03d2\3\2\2\2\u008d\u03d8\3\2\2\2\u008f"+
+		"\u03e1\3\2\2\2\u0091\u03e9\3\2\2\2\u0093\u03f1\3\2\2\2\u0095\u03f4\3\2"+
+		"\2\2\u0097\u03f9\3\2\2\2\u0099\u0400\3\2\2\2\u009b\u0405\3\2\2\2\u009d"+
+		"\u040a\3\2\2\2\u009f\u0411\3\2\2\2\u00a1\u0417\3\2\2\2\u00a3\u041c\3\2"+
+		"\2\2\u00a5\u0427\3\2\2\2\u00a7\u042e\3\2\2\2\u00a9\u0439\3\2\2\2\u00ab"+
+		"\u043f\3\2\2\2\u00ad\u0449\3\2\2\2\u00af\u0452\3\2\2\2\u00b1\u0457\3\2"+
+		"\2\2\u00b3\u045b\3\2\2\2\u00b5\u0463\3\2\2\2\u00b7\u0469\3\2\2\2\u00b9"+
+		"\u0471\3\2\2\2\u00bb\u0477\3\2\2\2\u00bd\u047b\3\2\2\2\u00bf\u0483\3\2"+
+		"\2\2\u00c1\u048c\3\2\2\2\u00c3\u0493\3\2\2\2\u00c5\u0498\3\2\2\2\u00c7"+
+		"\u049b\3\2\2\2\u00c9\u04a6\3\2\2\2\u00cb\u04ad\3\2\2\2\u00cd\u04b5\3\2"+
+		"\2\2\u00cf\u04c2\3\2\2\2\u00d1\u04cd\3\2\2\2\u00d3\u04d7\3\2\2\2\u00d5"+
+		"\u04dc\3\2\2\2\u00d7\u04e2\3\2\2\2\u00d9\u04e8\3\2\2\2\u00db\u04f2\3\2"+
+		"\2\2\u00dd\u04fc\3\2\2\2\u00df\u0502\3\2\2\2\u00e1\u0507\3\2\2\2\u00e3"+
+		"\u050b\3\2\2\2\u00e5\u050e\3\2\2\2\u00e7\u0512\3\2\2\2\u00e9\u0518\3\2"+
+		"\2\2\u00eb\u0522\3\2\2\2\u00ed\u0526\3\2\2\2\u00ef\u052b\3\2\2\2\u00f1"+
+		"\u0532\3\2\2\2\u00f3\u0539\3\2\2\2\u00f5\u0541\3\2\2\2\u00f7\u0547\3\2"+
+		"\2\2\u00f9\u054f\3\2\2\2\u00fb\u0559\3\2\2\2\u00fd\u0560\3\2\2\2\u00ff"+
+		"\u0569\3\2\2\2\u0101\u0571\3\2\2\2\u0103\u057e\3\2\2\2\u0105\u0587\3\2"+
+		"\2\2\u0107\u058e\3\2\2\2\u0109\u0595\3\2\2\2\u010b\u059c\3\2\2\2\u010d"+
+		"\u05a3\3\2\2\2\u010f\u05a9\3\2\2\2\u0111\u05af\3\2\2\2\u0113\u05b3\3\2"+
+		"\2\2\u0115\u05bd\3\2\2\2\u0117\u05c9\3\2\2\2\u0119\u05d1\3\2\2\2\u011b"+
+		"\u05d7\3\2\2\2\u011d\u05db\3\2\2\2\u011f\u05df\3\2\2\2\u0121\u05e5\3\2"+
+		"\2\2\u0123\u05eb\3\2\2\2\u0125\u05f0\3\2\2\2\u0127\u05f3\3\2\2\2\u0129"+
+		"\u05f9\3\2\2\2\u012b\u0602\3\2\2\2\u012d\u060f\3\2\2\2\u012f\u0615\3\2"+
+		"\2\2\u0131\u061b\3\2\2\2\u0133\u0622\3\2\2\2\u0135\u062f\3\2\2\2\u0137"+
+		"\u063b\3\2\2\2\u0139\u0646\3\2\2\2\u013b\u064f\3\2\2\2\u013d\u0657\3\2"+
+		"\2\2\u013f\u0662\3\2\2\2\u0141\u066a\3\2\2\2\u0143\u0672\3\2\2\2\u0145"+
+		"\u067d\3\2\2\2\u0147\u0686\3\2\2\2\u0149\u0692\3\2\2\2\u014b\u069a\3\2"+
+		"\2\2\u014d\u06a6\3\2\2\2\u014f\u06b4\3\2\2\2\u0151\u06be\3\2\2\2\u0153"+
+		"\u06c8\3\2\2\2\u0155\u06d5\3\2\2\2\u0157\u06e0\3\2\2\2\u0159\u06e9\3\2"+
+		"\2\2\u015b\u06f2\3\2\2\2\u015d\u06fa\3\2\2\2\u015f\u06fe\3\2\2\2\u0161"+
+		"\u0701\3\2\2\2\u0163\u0704\3\2\2\2\u0165\u0707\3\2\2\2\u0167\u070a\3\2"+
+		"\2\2\u0169\u070d\3\2\2\2\u016b\u0711\3\2\2\2\u016d\u0715\3\2\2\2\u016f"+
+		"\u071c\3\2\2\2\u0171\u071e\3\2\2\2\u0173\u0721\3\2\2\2\u0175\u0724\3\2"+
+		"\2\2\u0177\u0727\3\2\2\2\u0179\u072a\3\2\2\2\u017b\u072d\3\2\2\2\u017d"+
+		"\u0730\3\2\2\2\u017f\u0734\3\2\2\2\u0181\u0737\3\2\2\2\u0183\u073a\3\2"+
+		"\2\2\u0185\u073d\3\2\2\2\u0187\u0741\3\2\2\2\u0189\u0745\3\2\2\2\u018b"+
+		"\u0748\3\2\2\2\u018d\u074b\3\2\2\2\u018f\u074e\3\2\2\2\u0191\u0751\3\2"+
+		"\2\2\u0193\u0754\3\2\2\2\u0195\u0757\3\2\2\2\u0197\u075b\3\2\2\2\u0199"+
+		"\u075e\3\2\2\2\u019b\u0761\3\2\2\2\u019d\u0764\3\2\2\2\u019f\u0767\3\2"+
+		"\2\2\u01a1\u0769\3\2\2\2\u01a3\u076d\3\2\2\2\u01a5\u076f\3\2\2\2\u01a7"+
+		"\u0771\3\2\2\2\u01a9\u0773\3\2\2\2\u01ab\u0775\3\2\2\2\u01ad\u0777\3\2"+
+		"\2\2\u01af\u0779\3\2\2\2\u01b1\u077b\3\2\2\2\u01b3\u077d\3\2\2\2\u01b5"+
+		"\u077f\3\2\2\2\u01b7\u0781\3\2\2\2\u01b9\u0783\3\2\2\2\u01bb\u0785\3\2"+
+		"\2\2\u01bd\u0787\3\2\2\2\u01bf\u0789\3\2\2\2\u01c1\u078b\3\2\2\2\u01c3"+
+		"\u078d\3\2\2\2\u01c5\u078f\3\2\2\2\u01c7\u0791\3\2\2\2\u01c9\u0793\3\2"+
+		"\2\2\u01cb\u0795\3\2\2\2\u01cd\u0797\3\2\2\2\u01cf\u079a\3\2\2\2\u01d1"+
+		"\u079c\3\2\2\2\u01d3\u079e\3\2\2\2\u01d5\u07a0\3\2\2\2\u01d7\u07a2\3\2"+
+		"\2\2\u01d9\u07a4\3\2\2\2\u01db\u07a6\3\2\2\2\u01dd\u07a9\3\2\2\2\u01df"+
+		"\u07b0\3\2\2\2\u01e1\u07d7\3\2\2\2\u01e3\u07ef\3\2\2\2\u01e5\u07f1\3\2"+
+		"\2\2\u01e7\u0804\3\2\2\2\u01e9\u0817\3\2\2\2\u01eb\u0820\3\2\2\2\u01ed"+
+		"\u082b\3\2\2\2\u01ef\u082f\3\2\2\2\u01f1\u0840\3\2\2\2\u01f3\u084f\3\2"+
+		"\2\2\u01f5\u0853\3\2\2\2\u01f7\u0858\3\2\2\2\u01f9\u085c\3\2\2\2\u01fb"+
+		"\u0863\3\2\2\2\u01fd\u0867\3\2\2\2\u01ff\u086c\3\2\2\2\u0201\u0871\3\2"+
+		"\2\2\u0203\u087e\3\2\2\2\u0205\u0883\3\2\2\2\u0207\u0889\3\2\2\2\u0209"+
+		"\u088c\3\2\2\2\u020b\u0891\3\2\2\2\u020d\u0899\3\2\2\2\u020f\u08a3\3\2"+
+		"\2\2\u0211\u08ab\3\2\2\2\u0213\u08b6\3\2\2\2\u0215\u08c1\3\2\2\2\u0217"+
+		"\u08c4\3\2\2\2\u0219\u08c7\3\2\2\2\u021b\u08d6\3\2\2\2\u021d\u08dc\3\2"+
+		"\2\2\u021f\u08de\3\2\2\2\u0221\u08e0\3\2\2\2\u0223\u08e2\3\2\2\2\u0225"+
+		"\u0227\t\2\2\2\u0226\u0225\3\2\2\2\u0227\u0228\3\2\2\2\u0228\u0226\3\2"+
+		"\2\2\u0228\u0229\3\2\2\2\u0229\u022a\3\2\2\2\u022a\u022b\b\2\2\2\u022b"+
+		"\16\3\2\2\2\u022c\u022e\n\3\2\2\u022d\u022c\3\2\2\2\u022e\u022f\3\2\2"+
+		"\2\u022f\u022d\3\2\2\2\u022f\u0230\3\2\2\2\u0230\20\3\2\2\2\u0231\u0232"+
+		"\7>\2\2\u0232\u0233\7A\2\2\u0233\u0234\7z\2\2\u0234\u0235\7o\2\2\u0235"+
+		"\u0236\7n\2\2\u0236\u0237\3\2\2\2\u0237\u0238\b\4\3\2\u0238\22\3\2\2\2"+
+		"\u0239\u023a\5\u020f\u0103\2\u023a\u023b\3\2\2\2\u023b\u023c\b\5\4\2\u023c"+
+		"\u023d\b\5\5\2\u023d\24\3\2\2\2\u023e\u023f\5\u0211\u0104\2\u023f\u0240"+
+		"\3\2\2\2\u0240\u0241\b\6\6\2\u0241\u0242\b\6\5\2\u0242\26\3\2\2\2\u0243"+
+		"\u0244\7>\2\2\u0244\u0245\7u\2\2\u0245\u0246\7e\2\2\u0246\u0247\7t\2\2"+
+		"\u0247\u0248\7k\2\2\u0248\u0249\7r\2\2\u0249\u024a\7v\2\2\u024a\u024b"+
+		"\3\2\2\2\u024b\u024c\b\7\7\2\u024c\u024d\3\2\2\2\u024d\u024e\b\7\b\2\u024e"+
+		"\30\3\2\2\2\u024f\u0250\7>\2\2\u0250\u0251\7u\2\2\u0251\u0252\7v\2\2\u0252"+
+		"\u0253\7{\2\2\u0253\u0254\7n\2\2\u0254\u0255\7g\2\2\u0255\u0256\3\2\2"+
+		"\2\u0256\u0257\b\b\t\2\u0257\u0258\3\2\2\2\u0258\u0259\b\b\b\2\u0259\32"+
+		"\3\2\2\2\u025a\u025b\7>\2\2\u025b\u025c\7#\2\2\u025c\u025d\3\2\2\2\u025d"+
+		"\u025e\7/\2\2\u025e\u025f\7/\2\2\u025f\u0263\3\2\2\2\u0260\u0262\13\2"+
+		"\2\2\u0261\u0260\3\2\2\2\u0262\u0265\3\2\2\2\u0263\u0264\3\2\2\2\u0263"+
+		"\u0261\3\2\2\2\u0264\u0266\3\2\2\2\u0265\u0263\3\2\2\2\u0266\u0267\7/"+
+		"\2\2\u0267\u0268\7/\2\2\u0268\u0269\7@\2\2\u0269\u026a\3\2\2\2\u026a\u026b"+
+		"\b\t\2\2\u026b\34\3\2\2\2\u026c\u026d\7>\2\2\u026d\u026e\7#\2\2\u026e"+
+		"\u0272\3\2\2\2\u026f\u0271\13\2\2\2\u0270\u026f\3\2\2\2\u0271\u0274\3"+
+		"\2\2\2\u0272\u0273\3\2\2\2\u0272\u0270\3\2\2\2\u0273\u0275\3\2\2\2\u0274"+
+		"\u0272\3\2\2\2\u0275\u0276\7@\2\2\u0276\36\3\2\2\2\u0277\u0278\7>\2\2"+
+		"\u0278\u0279\3\2\2\2\u0279\u027a\b\13\b\2\u027a \3\2\2\2\u027b\u027c\7"+
+		"%\2\2\u027c\u027d\6\f\2\2\u027d\u0281\7#\2\2\u027e\u0280\n\4\2\2\u027f"+
+		"\u027e\3\2\2\2\u0280\u0283\3\2\2\2\u0281\u027f\3\2\2\2\u0281\u0282\3\2"+
+		"\2\2\u0282\"\3\2\2\2\u0283\u0281\3\2\2\2\u0284\u0288\7%\2\2\u0285\u0287"+
+		"\n\5\2\2\u0286\u0285\3\2\2\2\u0287\u028a\3\2\2\2\u0288\u0286\3\2\2\2\u0288"+
+		"\u0289\3\2\2\2\u0289\u028b\3\2\2\2\u028a\u0288\3\2\2\2\u028b\u028c\b\r"+
+		"\n\2\u028c$\3\2\2\2\u028d\u028e\13\2\2\2\u028e\u028f\3\2\2\2\u028f\u0290"+
+		"\b\16\13\2\u0290&\3\2\2\2\u0291\u0293\n\6\2\2\u0292\u0291\3\2\2\2\u0293"+
+		"\u0294\3\2\2\2\u0294\u0292\3\2\2\2\u0294\u0295\3\2\2\2\u0295(\3\2\2\2"+
+		"\u0296\u0297\7A\2\2\u0297\u0298\7@\2\2\u0298\u0299\3\2\2\2\u0299\u029a"+
+		"\b\20\f\2\u029a*\3\2\2\2\u029b\u029c\7A\2\2\u029c\u029d\3\2\2\2\u029d"+
+		"\u029e\b\21\r\2\u029e,\3\2\2\2\u029f\u02a0\5\u020f\u0103\2\u02a0\u02a1"+
+		"\3\2\2\2\u02a1\u02a2\b\22\4\2\u02a2\u02a3\b\22\5\2\u02a3.\3\2\2\2\u02a4"+
+		"\u02a5\5\u0211\u0104\2\u02a5\u02a6\3\2\2\2\u02a6\u02a7\b\23\6\2\u02a7"+
+		"\u02a8\b\23\5\2\u02a8\60\3\2\2\2\u02a9\u02aa\7@\2\2\u02aa\u02ab\b\24\16"+
+		"\2\u02ab\62\3\2\2\2\u02ac\u02ad\7\61\2\2\u02ad\u02ae\7@\2\2\u02ae\u02af"+
+		"\3\2\2\2\u02af\u02b0\b\25\f\2\u02b0\64\3\2\2\2\u02b1\u02b2\7\61\2\2\u02b2"+
+		"\66\3\2\2\2\u02b3\u02b4\7?\2\2\u02b48\3\2\2\2\u02b5\u02b7\7^\2\2\u02b6"+
+		"\u02b5\3\2\2\2\u02b6\u02b7\3\2\2\2\u02b7\u02b8\3\2\2\2\u02b8\u02b9\7)"+
+		"\2\2\u02b9\u02ba\3\2\2\2\u02ba\u02bb\b\30\17\2\u02bb:\3\2\2\2\u02bc\u02be"+
+		"\7^\2\2\u02bd\u02bc\3\2\2\2\u02bd\u02be\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf"+
+		"\u02c0\7$\2\2\u02c0\u02c1\3\2\2\2\u02c1\u02c2\b\31\20\2\u02c2<\3\2\2\2"+
+		"\u02c3\u02c5\7%\2\2\u02c4\u02c6\5\u0223\u010d\2\u02c5\u02c4\3\2\2\2\u02c6"+
+		"\u02c7\3\2\2\2\u02c7\u02c5\3\2\2\2\u02c7\u02c8\3\2\2\2\u02c8>\3\2\2\2"+
+		"\u02c9\u02cb\5\u021f\u010b\2\u02ca\u02c9\3\2\2\2\u02cb\u02cc\3\2\2\2\u02cc"+
+		"\u02ca\3\2\2\2\u02cc\u02cd\3\2\2\2\u02cd@\3\2\2\2\u02ce\u02d0\t\2\2\2"+
+		"\u02cf\u02ce\3\2\2\2\u02d0\u02d1\3\2\2\2\u02d1\u02cf\3\2\2\2\u02d1\u02d2"+
+		"\3\2\2\2\u02d2\u02d3\3\2\2\2\u02d3\u02d4\b\34\2\2\u02d4B\3\2\2\2\u02d5"+
+		"\u02d9\5\u0217\u0107\2\u02d6\u02d8\5\u0215\u0106\2\u02d7\u02d6\3\2\2\2"+
+		"\u02d8\u02db\3\2\2\2\u02d9\u02d7\3\2\2\2\u02d9\u02da\3\2\2\2\u02daD\3"+
+		"\2\2\2\u02db\u02d9\3\2\2\2\u02dc\u02dd\13\2\2\2\u02dd\u02de\3\2\2\2\u02de"+
+		"\u02df\b\36\13\2\u02dfF\3\2\2\2\u02e0\u02e1\5\u020f\u0103\2\u02e1\u02e2"+
+		"\3\2\2\2\u02e2\u02e3\b\37\4\2\u02e3\u02e4\b\37\5\2\u02e4H\3\2\2\2\u02e5"+
+		"\u02e6\5\u0211\u0104\2\u02e6\u02e7\3\2\2\2\u02e7\u02e8\b \6\2\u02e8\u02e9"+
+		"\b \5\2\u02e9J\3\2\2\2\u02ea\u02ec\7)\2\2\u02eb\u02ed\7)\2\2\u02ec\u02eb"+
+		"\3\2\2\2\u02ec\u02ed\3\2\2\2\u02ed\u02ee\3\2\2\2\u02ee\u02ef\b!\f\2\u02ef"+
+		"L\3\2\2\2\u02f0\u02f2\n\7\2\2\u02f1\u02f0\3\2\2\2\u02f2\u02f3\3\2\2\2"+
+		"\u02f3\u02f1\3\2\2\2\u02f3\u02f4\3\2\2\2\u02f4N\3\2\2\2\u02f5\u02f6\13"+
+		"\2\2\2\u02f6\u02f7\3\2\2\2\u02f7\u02f8\b#\13\2\u02f8P\3\2\2\2\u02f9\u02fa"+
+		"\5\u020f\u0103\2\u02fa\u02fb\3\2\2\2\u02fb\u02fc\b$\4\2\u02fc\u02fd\b"+
+		"$\5\2\u02fdR\3\2\2\2\u02fe\u02ff\5\u0211\u0104\2\u02ff\u0300\3\2\2\2\u0300"+
+		"\u0301\b%\6\2\u0301\u0302\b%\5\2\u0302T\3\2\2\2\u0303\u0305\7$\2\2\u0304"+
+		"\u0306\7$\2\2\u0305\u0304\3\2\2\2\u0305\u0306\3\2\2\2\u0306\u0307\3\2"+
+		"\2\2\u0307\u0308\b&\f\2\u0308V\3\2\2\2\u0309\u030b\n\b\2\2\u030a\u0309"+
+		"\3\2\2\2\u030b\u030c\3\2\2\2\u030c\u030a\3\2\2\2\u030c\u030d\3\2\2\2\u030d"+
+		"X\3\2\2\2\u030e\u030f\13\2\2\2\u030f\u0310\3\2\2\2\u0310\u0311\b(\13\2"+
+		"\u0311Z\3\2\2\2\u0312\u0314\n\5\2\2\u0313\u0312\3\2\2\2\u0314\u0315\3"+
+		"\2\2\2\u0315\u0313\3\2\2\2\u0315\u0316\3\2\2\2\u0316\\\3\2\2\2\u0317\u0318"+
+		"\7>\2\2\u0318\u0319\7\61\2\2\u0319\u0320\3\2\2\2\u031a\u031b\7u\2\2\u031b"+
+		"\u031c\7e\2\2\u031c\u031d\7t\2\2\u031d\u031e\7k\2\2\u031e\u031f\7r\2\2"+
+		"\u031f\u0321\7v\2\2\u0320\u031a\3\2\2\2\u0320\u0321\3\2\2\2\u0321\u0322"+
+		"\3\2\2\2\u0322\u0323\7@\2\2\u0323\u0324\3\2\2\2\u0324\u0325\b*\f\2\u0325"+
+		"^\3\2\2\2\u0326\u0327\5\u020f\u0103\2\u0327\u0328\3\2\2\2\u0328\u0329"+
+		"\b+\4\2\u0329\u032a\b+\5\2\u032a`\3\2\2\2\u032b\u032c\5\u0211\u0104\2"+
+		"\u032c\u032d\3\2\2\2\u032d\u032e\b,\6\2\u032e\u032f\b,\5\2\u032fb\3\2"+
+		"\2\2\u0330\u0331\7>\2\2\u0331\u0332\3\2\2\2\u0332\u0333\b-\21\2\u0333"+
+		"d\3\2\2\2\u0334\u0336\13\2\2\2\u0335\u0334\3\2\2\2\u0336\u0339\3\2\2\2"+
+		"\u0337\u0338\3\2\2\2\u0337\u0335\3\2\2\2\u0338\u033a\3\2\2\2\u0339\u0337"+
+		"\3\2\2\2\u033a\u033b\7>\2\2\u033b\u033c\7\61\2\2\u033c\u0342\3\2\2\2\u033d"+
+		"\u033e\7u\2\2\u033e\u033f\7v\2\2\u033f\u0340\7{\2\2\u0340\u0341\7n\2\2"+
+		"\u0341\u0343\7g\2\2\u0342\u033d\3\2\2\2\u0342\u0343\3\2\2\2\u0343\u0344"+
+		"\3\2\2\2\u0344\u0345\7@\2\2\u0345\u0346\3\2\2\2\u0346\u0347\b.\f\2\u0347"+
+		"f\3\2\2\2\u0348\u034c\7A\2\2\u0349\u034a\7\'\2\2\u034a\u034c\6/\3\2\u034b"+
+		"\u0348\3\2\2\2\u034b\u0349\3\2\2\2\u034c\u034d\3\2\2\2\u034d\u035a\7@"+
+		"\2\2\u034e\u034f\7>\2\2\u034f\u0350\7\61\2\2\u0350\u0351\7u\2\2\u0351"+
+		"\u0352\7e\2\2\u0352\u0353\7t\2\2\u0353\u0354\7k\2\2\u0354\u0355\7r\2\2"+
+		"\u0355\u0356\7v\2\2\u0356\u0357\7@\2\2\u0357\u0358\3\2\2\2\u0358\u035a"+
+		"\6/\4\2\u0359\u034b\3\2\2\2\u0359\u034e\3\2\2\2\u035ah\3\2\2\2\u035b\u035d"+
+		"\t\2\2\2\u035c\u035b\3\2\2\2\u035d\u035e\3\2\2\2\u035e\u035c\3\2\2\2\u035e"+
+		"\u035f\3\2\2\2\u035f\u0360\3\2\2\2\u0360\u0361\b\60\6\2\u0361j\3\2\2\2"+
+		"\u0362\u0363\7\61\2\2\u0363\u0364\7,\2\2\u0364\u0368\3\2\2\2\u0365\u0367"+
+		"\13\2\2\2\u0366\u0365\3\2\2\2\u0367\u036a\3\2\2\2\u0368\u0369\3\2\2\2"+
+		"\u0368\u0366\3\2\2\2\u0369\u036b\3\2\2\2\u036a\u0368\3\2\2\2\u036b\u036c"+
+		"\7,\2\2\u036c\u036d\7\61\2\2\u036d\u036e\3\2\2\2\u036e\u036f\b\61\22\2"+
+		"\u036fl\3\2\2\2\u0370\u0371\7\61\2\2\u0371\u0372\7\61\2\2\u0372\u0373"+
+		"\3\2\2\2\u0373\u0374\b\62\6\2\u0374\u0375\b\62\23\2\u0375n\3\2\2\2\u0376"+
+		"\u0377\7%\2\2\u0377\u0378\3\2\2\2\u0378\u0379\b\63\6\2\u0379\u037a\b\63"+
+		"\23\2\u037ap\3\2\2\2\u037b\u037c\7%\2\2\u037c\u037d\7]\2\2\u037dr\3\2"+
+		"\2\2\u037e\u037f\7c\2\2\u037f\u0380\7d\2\2\u0380\u0381\7u\2\2\u0381\u0382"+
+		"\7v\2\2\u0382\u0383\7t\2\2\u0383\u0384\7c\2\2\u0384\u0385\7e\2\2\u0385"+
+		"\u0386\7v\2\2\u0386t\3\2\2\2\u0387\u0388\7c\2\2\u0388\u0389\7t\2\2\u0389"+
+		"\u038a\7t\2\2\u038a\u038b\7c\2\2\u038b\u038c\7{\2\2\u038cv\3\2\2\2\u038d"+
+		"\u038e\7c\2\2\u038e\u038f\7u\2\2\u038fx\3\2\2\2\u0390\u0391\7d\2\2\u0391"+
+		"\u0392\7k\2\2\u0392\u0393\7p\2\2\u0393\u0394\7c\2\2\u0394\u0395\7t\2\2"+
+		"\u0395\u0396\7{\2\2\u0396z\3\2\2\2\u0397\u0398\7d\2\2\u0398\u0399\7q\2"+
+		"\2\u0399\u039a\7q\2\2\u039a\u039b\7n\2\2\u039b\u039f\3\2\2\2\u039c\u039d"+
+		"\7g\2\2\u039d\u039e\7c\2\2\u039e\u03a0\7p\2\2\u039f\u039c\3\2\2\2\u039f"+
+		"\u03a0\3\2\2\2\u03a0|\3\2\2\2\u03a1\u03a2\7v\2\2\u03a2\u03a3\7t\2\2\u03a3"+
+		"\u03a4\7w\2\2\u03a4\u03ab\7g\2\2\u03a5\u03a6\7h\2\2\u03a6\u03a7\7c\2\2"+
+		"\u03a7\u03a8\7n\2\2\u03a8\u03a9\7u\2\2\u03a9\u03ab\7g\2\2\u03aa\u03a1"+
+		"\3\2\2\2\u03aa\u03a5\3\2\2\2\u03ab~\3\2\2\2\u03ac\u03ad\7d\2\2\u03ad\u03ae"+
+		"\7t\2\2\u03ae\u03af\7g\2\2\u03af\u03b0\7c\2\2\u03b0\u03b1\7m\2\2\u03b1"+
+		"\u0080\3\2\2\2\u03b2\u03b3\7e\2\2\u03b3\u03b4\7c\2\2\u03b4\u03b5\7n\2"+
+		"\2\u03b5\u03b6\7n\2\2\u03b6\u03b7\7c\2\2\u03b7\u03b8\7d\2\2\u03b8\u03b9"+
+		"\7n\2\2\u03b9\u03ba\7g\2\2\u03ba\u0082\3\2\2\2\u03bb\u03bc\7e\2\2\u03bc"+
+		"\u03bd\7c\2\2\u03bd\u03be\7u\2\2\u03be\u03bf\7g\2\2\u03bf\u0084\3\2\2"+
+		"\2\u03c0\u03c1\7e\2\2\u03c1\u03c2\7c\2\2\u03c2\u03c3\7v\2\2\u03c3\u03c4"+
+		"\7e\2\2\u03c4\u03c5\7j\2\2\u03c5\u0086\3\2\2\2\u03c6\u03c7\7e\2\2\u03c7"+
+		"\u03c8\7n\2\2\u03c8\u03c9\7c\2\2\u03c9\u03ca\7u\2\2\u03ca\u03cb\7u\2\2"+
+		"\u03cb\u0088\3\2\2\2\u03cc\u03cd\7e\2\2\u03cd\u03ce\7n\2\2\u03ce\u03cf"+
+		"\7q\2\2\u03cf\u03d0\7p\2\2\u03d0\u03d1\7g\2\2\u03d1\u008a\3\2\2\2\u03d2"+
+		"\u03d3\7e\2\2\u03d3\u03d4\7q\2\2\u03d4\u03d5\7p\2\2\u03d5\u03d6\7u\2\2"+
+		"\u03d6\u03d7\7v\2\2\u03d7\u008c\3\2\2\2\u03d8\u03d9\7e\2\2\u03d9\u03da"+
+		"\7q\2\2\u03da\u03db\7p\2\2\u03db\u03dc\7v\2\2\u03dc\u03dd\7k\2\2\u03dd"+
+		"\u03de\7p\2\2\u03de\u03df\7w\2\2\u03df\u03e0\7g\2\2\u03e0\u008e\3\2\2"+
+		"\2\u03e1\u03e2\7f\2\2\u03e2\u03e3\7g\2\2\u03e3\u03e4\7e\2\2\u03e4\u03e5"+
+		"\7n\2\2\u03e5\u03e6\7c\2\2\u03e6\u03e7\7t\2\2\u03e7\u03e8\7g\2\2\u03e8"+
+		"\u0090\3\2\2\2\u03e9\u03ea\7f\2\2\u03ea\u03eb\7g\2\2\u03eb\u03ec\7h\2"+
+		"\2\u03ec\u03ed\7c\2\2\u03ed\u03ee\7w\2\2\u03ee\u03ef\7n\2\2\u03ef\u03f0"+
+		"\7v\2\2\u03f0\u0092\3\2\2\2\u03f1\u03f2\7f\2\2\u03f2\u03f3\7q\2\2\u03f3"+
+		"\u0094\3\2\2\2\u03f4\u03f5\7t\2\2\u03f5\u03f6\7g\2\2\u03f6\u03f7\7c\2"+
+		"\2\u03f7\u03f8\7n\2\2\u03f8\u0096\3\2\2\2\u03f9\u03fa\7f\2\2\u03fa\u03fb"+
+		"\7q\2\2\u03fb\u03fc\7w\2\2\u03fc\u03fd\7d\2\2\u03fd\u03fe\7n\2\2\u03fe"+
+		"\u03ff\7g\2\2\u03ff\u0098\3\2\2\2\u0400\u0401\7g\2\2\u0401\u0402\7e\2"+
+		"\2\u0402\u0403\7j\2\2\u0403\u0404\7q\2\2\u0404\u009a\3\2\2\2\u0405\u0406"+
+		"\7g\2\2\u0406\u0407\7n\2\2\u0407\u0408\7u\2\2\u0408\u0409\7g\2\2\u0409"+
+		"\u009c\3\2\2\2\u040a\u040b\7g\2\2\u040b\u040c\7n\2\2\u040c\u040d\7u\2"+
+		"\2\u040d\u040e\7g\2\2\u040e\u040f\7k\2\2\u040f\u0410\7h\2\2\u0410\u009e"+
+		"\3\2\2\2\u0411\u0412\7g\2\2\u0412\u0413\7o\2\2\u0413\u0414\7r\2\2\u0414"+
+		"\u0415\7v\2\2\u0415\u0416\7{\2\2\u0416\u00a0\3\2\2\2\u0417\u0418\7g\2"+
+		"\2\u0418\u0419\7p\2\2\u0419\u041a\7w\2\2\u041a\u041b\7o\2\2\u041b\u00a2"+
+		"\3\2\2\2\u041c\u041d\7g\2\2\u041d\u041e\7p\2\2\u041e\u041f\7f\2\2\u041f"+
+		"\u0420\7f\2\2\u0420\u0421\7g\2\2\u0421\u0422\7e\2\2\u0422\u0423\7n\2\2"+
+		"\u0423\u0424\7c\2\2\u0424\u0425\7t\2\2\u0425\u0426\7g\2\2\u0426\u00a4"+
+		"\3\2\2\2\u0427\u0428\7g\2\2\u0428\u0429\7p\2\2\u0429\u042a\7f\2\2\u042a"+
+		"\u042b\7h\2\2\u042b\u042c\7q\2\2\u042c\u042d\7t\2\2\u042d\u00a6\3\2\2"+
+		"\2\u042e\u042f\7g\2\2\u042f\u0430\7p\2\2\u0430\u0431\7f\2\2\u0431\u0432"+
+		"\7h\2\2\u0432\u0433\7q\2\2\u0433\u0434\7t\2\2\u0434\u0435\7g\2\2\u0435"+
+		"\u0436\7c\2\2\u0436\u0437\7e\2\2\u0437\u0438\7j\2\2\u0438\u00a8\3\2\2"+
+		"\2\u0439\u043a\7g\2\2\u043a\u043b\7p\2\2\u043b\u043c\7f\2\2\u043c\u043d"+
+		"\7k\2\2\u043d\u043e\7h\2\2\u043e\u00aa\3\2\2\2\u043f\u0440\7g\2\2\u0440"+
+		"\u0441\7p\2\2\u0441\u0442\7f\2\2\u0442\u0443\7u\2\2\u0443\u0444\7y\2\2"+
+		"\u0444\u0445\7k\2\2\u0445\u0446\7v\2\2\u0446\u0447\7e\2\2\u0447\u0448"+
+		"\7j\2\2\u0448\u00ac\3\2\2\2\u0449\u044a\7g\2\2\u044a\u044b\7p\2\2\u044b"+
+		"\u044c\7f\2\2\u044c\u044d\7y\2\2\u044d\u044e\7j\2\2\u044e\u044f\7k\2\2"+
+		"\u044f\u0450\7n\2\2\u0450\u0451\7g\2\2\u0451\u00ae\3\2\2\2\u0452\u0453"+
+		"\7g\2\2\u0453\u0454\7x\2\2\u0454\u0455\7c\2\2\u0455\u0456\7n\2\2\u0456"+
+		"\u00b0\3\2\2\2\u0457\u0458\7f\2\2\u0458\u0459\7k\2\2\u0459\u045a\7g\2"+
+		"\2\u045a\u00b2\3\2\2\2\u045b\u045c\7g\2\2\u045c\u045d\7z\2\2\u045d\u045e"+
+		"\7v\2\2\u045e\u045f\7g\2\2\u045f\u0460\7p\2\2\u0460\u0461\7f\2\2\u0461"+
+		"\u0462\7u\2\2\u0462\u00b4\3\2\2\2\u0463\u0464\7h\2\2\u0464\u0465\7k\2"+
+		"\2\u0465\u0466\7p\2\2\u0466\u0467\7c\2\2\u0467\u0468\7n\2\2\u0468\u00b6"+
+		"\3\2\2\2\u0469\u046a\7h\2\2\u046a\u046b\7k\2\2\u046b\u046c\7p\2\2\u046c"+
+		"\u046d\7c\2\2\u046d\u046e\7n\2\2\u046e\u046f\7n\2\2\u046f\u0470\7{\2\2"+
+		"\u0470\u00b8\3\2\2\2\u0471\u0472\7h\2\2\u0472\u0473\7n\2\2\u0473\u0474"+
+		"\7q\2\2\u0474\u0475\7c\2\2\u0475\u0476\7v\2\2\u0476\u00ba\3\2\2\2\u0477"+
+		"\u0478\7h\2\2\u0478\u0479\7q\2\2\u0479\u047a\7t\2\2\u047a\u00bc\3\2\2"+
+		"\2\u047b\u047c\7h\2\2\u047c\u047d\7q\2\2\u047d\u047e\7t\2\2\u047e\u047f"+
+		"\7g\2\2\u047f\u0480\7c\2\2\u0480\u0481\7e\2\2\u0481\u0482\7j\2\2\u0482"+
+		"\u00be\3\2\2\2\u0483\u0484\7h\2\2\u0484\u0485\7w\2\2\u0485\u0486\7p\2"+
+		"\2\u0486\u0487\7e\2\2\u0487\u0488\7v\2\2\u0488\u0489\7k\2\2\u0489\u048a"+
+		"\7q\2\2\u048a\u048b\7p\2\2\u048b\u00c0\3\2\2\2\u048c\u048d\7i\2\2\u048d"+
+		"\u048e\7n\2\2\u048e\u048f\7q\2\2\u048f\u0490\7d\2\2\u0490\u0491\7c\2\2"+
+		"\u0491\u0492\7n\2\2\u0492\u00c2\3\2\2\2\u0493\u0494\7i\2\2\u0494\u0495"+
+		"\7q\2\2\u0495\u0496\7v\2\2\u0496\u0497\7q\2\2\u0497\u00c4\3\2\2\2\u0498"+
+		"\u0499\7k\2\2\u0499\u049a\7h\2\2\u049a\u00c6\3\2\2\2\u049b\u049c\7k\2"+
+		"\2\u049c\u049d\7o\2\2\u049d\u049e\7r\2\2\u049e\u049f\7n\2\2\u049f\u04a0"+
+		"\7g\2\2\u04a0\u04a1\7o\2\2\u04a1\u04a2\7g\2\2\u04a2\u04a3\7p\2\2\u04a3"+
+		"\u04a4\7v\2\2\u04a4\u04a5\7u\2\2\u04a5\u00c8\3\2\2\2\u04a6\u04a7\7k\2"+
+		"\2\u04a7\u04a8\7o\2\2\u04a8\u04a9\7r\2\2\u04a9\u04aa\7q\2\2\u04aa\u04ab"+
+		"\7t\2\2\u04ab\u04ac\7v\2\2\u04ac\u00ca\3\2\2\2\u04ad\u04ae\7k\2\2\u04ae"+
+		"\u04af\7p\2\2\u04af\u04b0\7e\2\2\u04b0\u04b1\7n\2\2\u04b1\u04b2\7w\2\2"+
+		"\u04b2\u04b3\7f\2\2\u04b3\u04b4\7g\2\2\u04b4\u00cc\3\2\2\2\u04b5\u04b6"+
+		"\7k\2\2\u04b6\u04b7\7p\2\2\u04b7\u04b8\7e\2\2\u04b8\u04b9\7n\2\2\u04b9"+
+		"\u04ba\7w\2\2\u04ba\u04bb\7f\2\2\u04bb\u04bc\7g\2\2\u04bc\u04bd\7a\2\2"+
+		"\u04bd\u04be\7q\2\2\u04be\u04bf\7p\2\2\u04bf\u04c0\7e\2\2\u04c0\u04c1"+
+		"\7g\2\2\u04c1\u00ce\3\2\2\2\u04c2\u04c3\7k\2\2\u04c3\u04c4\7p\2\2\u04c4"+
+		"\u04c5\7u\2\2\u04c5\u04c6\7v\2\2\u04c6\u04c7\7c\2\2\u04c7\u04c8\7p\2\2"+
+		"\u04c8\u04c9\7e\2\2\u04c9\u04ca\7g\2\2\u04ca\u04cb\7q\2\2\u04cb\u04cc"+
+		"\7h\2\2\u04cc\u00d0\3\2\2\2\u04cd\u04ce\7k\2\2\u04ce\u04cf\7p\2\2\u04cf"+
+		"\u04d0\7u\2\2\u04d0\u04d1\7v\2\2\u04d1\u04d2\7g\2\2\u04d2\u04d3\7c\2\2"+
+		"\u04d3\u04d4\7f\2\2\u04d4\u04d5\7q\2\2\u04d5\u04d6\7h\2\2\u04d6\u00d2"+
+		"\3\2\2\2\u04d7\u04d8\7k\2\2\u04d8\u04d9\7p\2\2\u04d9\u04da\7v\2\2\u04da"+
+		"\u04db\7:\2\2\u04db\u00d4\3\2\2\2\u04dc\u04dd\7k\2\2\u04dd\u04de\7p\2"+
+		"\2\u04de\u04df\7v\2\2\u04df\u04e0\7\63\2\2\u04e0\u04e1\78\2\2\u04e1\u00d6"+
+		"\3\2\2\2\u04e2\u04e3\7k\2\2\u04e3\u04e4\7p\2\2\u04e4\u04e5\7v\2\2\u04e5"+
+		"\u04e6\78\2\2\u04e6\u04e7\7\66\2\2\u04e7\u00d8\3\2\2\2\u04e8\u04e9\7k"+
+		"\2\2\u04e9\u04ea\7p\2\2\u04ea\u04eb\7v\2\2\u04eb\u04f0\3\2\2\2\u04ec\u04ed"+
+		"\7g\2\2\u04ed\u04ee\7i\2\2\u04ee\u04ef\7g\2\2\u04ef\u04f1\7t\2\2\u04f0"+
+		"\u04ec\3\2\2\2\u04f0\u04f1\3\2\2\2\u04f1\u00da\3\2\2\2\u04f2\u04f3\7k"+
+		"\2\2\u04f3\u04f4\7p\2\2\u04f4\u04f5\7v\2\2\u04f5\u04f6\7g\2\2\u04f6\u04f7"+
+		"\7t\2\2\u04f7\u04f8\7h\2\2\u04f8\u04f9\7c\2\2\u04f9\u04fa\7e\2\2\u04fa"+
+		"\u04fb\7g\2\2\u04fb\u00dc\3\2\2\2\u04fc\u04fd\7k\2\2\u04fd\u04fe\7u\2"+
+		"\2\u04fe\u04ff\7u\2\2\u04ff\u0500\7g\2\2\u0500\u0501\7v\2\2\u0501\u00de"+
+		"\3\2\2\2\u0502\u0503\7n\2\2\u0503\u0504\7k\2\2\u0504\u0505\7u\2\2\u0505"+
+		"\u0506\7v\2\2\u0506\u00e0\3\2\2\2\u0507\u0508\7c\2\2\u0508\u0509\7p\2"+
+		"\2\u0509\u050a\7f\2\2\u050a\u00e2\3\2\2\2\u050b\u050c\7q\2\2\u050c\u050d"+
+		"\7t\2\2\u050d\u00e4\3\2\2\2\u050e\u050f\7z\2\2\u050f\u0510\7q\2\2\u0510"+
+		"\u0511\7t\2\2\u0511\u00e6\3\2\2\2\u0512\u0513\7o\2\2\u0513\u0514\7c\2"+
+		"\2\u0514\u0515\7v\2\2\u0515\u0516\7e\2\2\u0516\u0517\7j\2\2\u0517\u00e8"+
+		"\3\2\2\2\u0518\u0519\7p\2\2\u0519\u051a\7c\2\2\u051a\u051b\7o\2\2\u051b"+
+		"\u051c\7g\2\2\u051c\u051d\7u\2\2\u051d\u051e\7r\2\2\u051e\u051f\7c\2\2"+
+		"\u051f\u0520\7e\2\2\u0520\u0521\7g\2\2\u0521\u00ea\3\2\2\2\u0522\u0523"+
+		"\7p\2\2\u0523\u0524\7g\2\2\u0524\u0525\7y\2\2\u0525\u00ec\3\2\2\2\u0526"+
+		"\u0527\7p\2\2\u0527\u0528\7w\2\2\u0528\u0529\7n\2\2\u0529\u052a\7n\2\2"+
+		"\u052a\u00ee\3\2\2\2\u052b\u052c\7q\2\2\u052c\u052d\7d\2\2\u052d\u052e"+
+		"\7l\2\2\u052e\u052f\7g\2\2\u052f\u0530\7e\2\2\u0530\u0531\7v\2\2\u0531"+
+		"\u00f0\3\2\2\2\u0532\u0533\7r\2\2\u0533\u0534\7c\2\2\u0534\u0535\7t\2"+
+		"\2\u0535\u0536\7g\2\2\u0536\u0537\7p\2\2\u0537\u0538\7v\2\2\u0538\u00f2"+
+		"\3\2\2\2\u0539\u053a\7r\2\2\u053a\u053b\7c\2\2\u053b\u053c\7t\2\2\u053c"+
+		"\u053d\7v\2\2\u053d\u053e\7k\2\2\u053e\u053f\7c\2\2\u053f\u0540\7n\2\2"+
+		"\u0540\u00f4\3\2\2\2\u0541\u0542\7r\2\2\u0542\u0543\7t\2\2\u0543\u0544"+
+		"\7k\2\2\u0544\u0545\7p\2\2\u0545\u0546\7v\2\2\u0546\u00f6\3\2\2\2\u0547"+
+		"\u0548\7r\2\2\u0548\u0549\7t\2\2\u0549\u054a\7k\2\2\u054a\u054b\7x\2\2"+
+		"\u054b\u054c\7c\2\2\u054c\u054d\7v\2\2\u054d\u054e\7g\2\2\u054e\u00f8"+
+		"\3\2\2\2\u054f\u0550\7r\2\2\u0550\u0551\7t\2\2\u0551\u0552\7q\2\2\u0552"+
+		"\u0553\7v\2\2\u0553\u0554\7g\2\2\u0554\u0555\7e\2\2\u0555\u0556\7v\2\2"+
+		"\u0556\u0557\7g\2\2\u0557\u0558\7f\2\2\u0558\u00fa\3\2\2\2\u0559\u055a"+
+		"\7r\2\2\u055a\u055b\7w\2\2\u055b\u055c\7d\2\2\u055c\u055d\7n\2\2\u055d"+
+		"\u055e\7k\2\2\u055e\u055f\7e\2\2\u055f\u00fc\3\2\2\2\u0560\u0561\7t\2"+
+		"\2\u0561\u0562\7g\2\2\u0562\u0563\7c\2\2\u0563\u0564\7f\2\2\u0564\u0565"+
+		"\7q\2\2\u0565\u0566\7p\2\2\u0566\u0567\7n\2\2\u0567\u0568\7{\2\2\u0568"+
+		"\u00fe\3\2\2\2\u0569\u056a\7t\2\2\u056a\u056b\7g\2\2\u056b\u056c\7s\2"+
+		"\2\u056c\u056d\7w\2\2\u056d\u056e\7k\2\2\u056e\u056f\7t\2\2\u056f\u0570"+
+		"\7g\2\2\u0570\u0100\3\2\2\2\u0571\u0572\7t\2\2\u0572\u0573\7g\2\2\u0573"+
+		"\u0574\7s\2\2\u0574\u0575\7w\2\2\u0575\u0576\7k\2\2\u0576\u0577\7t\2\2"+
+		"\u0577\u0578\7g\2\2\u0578\u0579\7a\2\2\u0579\u057a\7q\2\2\u057a\u057b"+
+		"\7p\2\2\u057b\u057c\7e\2\2\u057c\u057d\7g\2\2\u057d\u0102\3\2\2\2\u057e"+
+		"\u057f\7t\2\2\u057f\u0580\7g\2\2\u0580\u0581\7u\2\2\u0581\u0582\7q\2\2"+
+		"\u0582\u0583\7w\2\2\u0583\u0584\7t\2\2\u0584\u0585\7e\2\2\u0585\u0586"+
+		"\7g\2\2\u0586\u0104\3\2\2\2\u0587\u0588\7t\2\2\u0588\u0589\7g\2\2\u0589"+
+		"\u058a\7v\2\2\u058a\u058b\7w\2\2\u058b\u058c\7t\2\2\u058c\u058d\7p\2\2"+
+		"\u058d\u0106\3\2\2\2\u058e\u058f\7u\2\2\u058f\u0590\7v\2\2\u0590\u0591"+
+		"\7c\2\2\u0591\u0592\7v\2\2\u0592\u0593\7k\2\2\u0593\u0594\7e\2\2\u0594"+
+		"\u0108\3\2\2\2\u0595\u0596\7u\2\2\u0596\u0597\7v\2\2\u0597\u0598\7t\2"+
+		"\2\u0598\u0599\7k\2\2\u0599\u059a\7p\2\2\u059a\u059b\7i\2\2\u059b\u010a"+
+		"\3\2\2\2\u059c\u059d\7u\2\2\u059d\u059e\7y\2\2\u059e\u059f\7k\2\2\u059f"+
+		"\u05a0\7v\2\2\u05a0\u05a1\7e\2\2\u05a1\u05a2\7j\2\2\u05a2\u010c\3\2\2"+
+		"\2\u05a3\u05a4\7v\2\2\u05a4\u05a5\7j\2\2\u05a5\u05a6\7t\2\2\u05a6\u05a7"+
+		"\7q\2\2\u05a7\u05a8\7y\2\2\u05a8\u010e\3\2\2\2\u05a9\u05aa\7v\2\2\u05aa"+
+		"\u05ab\7t\2\2\u05ab\u05ac\7c\2\2\u05ac\u05ad\7k\2\2\u05ad\u05ae\7v\2\2"+
+		"\u05ae\u0110\3\2\2\2\u05af\u05b0\7v\2\2\u05b0\u05b1\7t\2\2\u05b1\u05b2"+
+		"\7{\2\2\u05b2\u0112\3\2\2\2\u05b3\u05b4\7e\2\2\u05b4\u05b5\7n\2\2\u05b5"+
+		"\u05b6\7t\2\2\u05b6\u05b7\7v\2\2\u05b7\u05b8\7{\2\2\u05b8\u05b9\7r\2\2"+
+		"\u05b9\u05ba\7g\2\2\u05ba\u05bb\7q\2\2\u05bb\u05bc\7h\2\2\u05bc\u0114"+
+		"\3\2\2\2\u05bd\u05be\7w\2\2\u05be\u05bf\7k\2\2\u05bf\u05c0\7p\2\2\u05c0"+
+		"\u05c1\7v\2\2\u05c1\u05c7\3\2\2\2\u05c2\u05c8\7:\2\2\u05c3\u05c4\7\63"+
+		"\2\2\u05c4\u05c8\78\2\2\u05c5\u05c6\78\2\2\u05c6\u05c8\7\66\2\2\u05c7"+
+		"\u05c2\3\2\2\2\u05c7\u05c3\3\2\2\2\u05c7\u05c5\3\2\2\2\u05c7\u05c8\3\2"+
+		"\2\2\u05c8\u0116\3\2\2\2\u05c9\u05ca\7w\2\2\u05ca\u05cb\7p\2\2\u05cb\u05cc"+
+		"\7k\2\2\u05cc\u05cd\7e\2\2\u05cd\u05ce\7q\2\2\u05ce\u05cf\7f\2\2\u05cf"+
+		"\u05d0\7g\2\2\u05d0\u0118\3\2\2\2\u05d1\u05d2\7w\2\2\u05d2\u05d3\7p\2"+
+		"\2\u05d3\u05d4\7u\2\2\u05d4\u05d5\7g\2\2\u05d5\u05d6\7v\2\2\u05d6\u011a"+
+		"\3\2\2\2\u05d7\u05d8\7w\2\2\u05d8\u05d9\7u\2\2\u05d9\u05da\7g\2\2\u05da"+
+		"\u011c\3\2\2\2\u05db\u05dc\7x\2\2\u05dc\u05dd\7c\2\2\u05dd\u05de\7t\2"+
+		"\2\u05de\u011e\3\2\2\2\u05df\u05e0\7y\2\2\u05e0\u05e1\7j\2\2\u05e1\u05e2"+
+		"\7k\2\2\u05e2\u05e3\7n\2\2\u05e3\u05e4\7g\2\2\u05e4\u0120\3\2\2\2\u05e5"+
+		"\u05e6\7{\2\2\u05e6\u05e7\7k\2\2\u05e7\u05e8\7g\2\2\u05e8\u05e9\7n\2\2"+
+		"\u05e9\u05ea\7f\2\2\u05ea\u0122\3\2\2\2\u05eb\u05ec\7h\2\2\u05ec\u05ed"+
+		"\7t\2\2\u05ed\u05ee\7q\2\2\u05ee\u05ef\7o\2\2\u05ef\u0124\3\2\2\2\u05f0"+
+		"\u05f1\7h\2\2\u05f1\u05f2\7p\2\2\u05f2\u0126\3\2\2\2\u05f3\u05f4\7v\2"+
+		"\2\u05f4\u05f5\7k\2\2\u05f5\u05f6\7e\2\2\u05f6\u05f7\7m\2\2\u05f7\u05f8"+
+		"\7u\2\2\u05f8\u0128\3\2\2\2\u05f9\u05fa\7g\2\2\u05fa\u05fb\7p\2\2\u05fb"+
+		"\u05fc\7e\2\2\u05fc\u05fd\7q\2\2\u05fd\u05fe\7f\2\2\u05fe\u05ff\7k\2\2"+
+		"\u05ff\u0600\7p\2\2\u0600\u0601\7i\2\2\u0601\u012a\3\2\2\2\u0602\u0603"+
+		"\7u\2\2\u0603\u0604\7v\2\2\u0604\u0605\7t\2\2\u0605\u0606\7k\2\2\u0606"+
+		"\u0607\7e\2\2\u0607\u0608\7v\2\2\u0608\u0609\7a\2\2\u0609\u060a\7v\2\2"+
+		"\u060a\u060b\7{\2\2\u060b\u060c\7r\2\2\u060c\u060d\7g\2\2\u060d\u060e"+
+		"\7u\2\2\u060e\u012c\3\2\2\2\u060f\u0610\7a\2\2\u0610\u0611\7a\2\2\u0611"+
+		"\u0612\7i\2\2\u0612\u0613\7g\2\2\u0613\u0614\7v\2\2\u0614\u012e\3\2\2"+
+		"\2\u0615\u0616\7a\2\2\u0616\u0617\7a\2\2\u0617\u0618\7u\2\2\u0618\u0619"+
+		"\7g\2\2\u0619\u061a\7v\2\2\u061a\u0130\3\2\2\2\u061b\u061c\7a\2\2\u061c"+
+		"\u061d\7a\2\2\u061d\u061e\7e\2\2\u061e\u061f\7c\2\2\u061f\u0620\7n\2\2"+
+		"\u0620\u0621\7n\2\2\u0621\u0132\3\2\2\2\u0622\u0623\7a\2\2\u0623\u0624"+
+		"\7a\2\2\u0624\u0625\7e\2\2\u0625\u0626\7c\2\2\u0626\u0627\7n\2\2\u0627"+
+		"\u0628\7n\2\2\u0628\u0629\7u\2\2\u0629\u062a\7v\2\2\u062a\u062b\7c\2\2"+
+		"\u062b\u062c\7v\2\2\u062c\u062d\7k\2\2\u062d\u062e\7e\2\2\u062e\u0134"+
+		"\3\2\2\2\u062f\u0630\7a\2\2\u0630\u0631\7a\2\2\u0631\u0632\7e\2\2\u0632"+
+		"\u0633\7q\2\2\u0633\u0634\7p\2\2\u0634\u0635\7u\2\2\u0635\u0636\7v\2\2"+
+		"\u0636\u0637\7t\2\2\u0637\u0638\7w\2\2\u0638\u0639\7e\2\2\u0639\u063a"+
+		"\7v\2\2\u063a\u0136\3\2\2\2\u063b\u063c\7a\2\2\u063c\u063d\7a\2\2\u063d"+
+		"\u063e\7f\2\2\u063e\u063f\7g\2\2\u063f\u0640\7u\2\2\u0640\u0641\7v\2\2"+
+		"\u0641\u0642\7t\2\2\u0642\u0643\7w\2\2\u0643\u0644\7e\2\2\u0644\u0645"+
+		"\7v\2\2\u0645\u0138\3\2\2\2\u0646\u0647\7a\2\2\u0647\u0648\7a\2\2\u0648"+
+		"\u0649\7y\2\2\u0649\u064a\7c\2\2\u064a\u064b\7m\2\2\u064b\u064c\7g\2\2"+
+		"\u064c\u064d\7w\2\2\u064d\u064e\7r\2\2\u064e\u013a\3\2\2\2\u064f\u0650"+
+		"\7a\2\2\u0650\u0651\7a\2\2\u0651\u0652\7u\2\2\u0652\u0653\7n\2\2\u0653"+
+		"\u0654\7g\2\2\u0654\u0655\7g\2\2\u0655\u0656\7r\2\2\u0656\u013c\3\2\2"+
+		"\2\u0657\u0658\7a\2\2\u0658\u0659\7a\2\2\u0659\u065a\7c\2\2\u065a\u065b"+
+		"\7w\2\2\u065b\u065c\7v\2\2\u065c\u065d\7q\2\2\u065d\u065e\7n\2\2\u065e"+
+		"\u065f\7q\2\2\u065f\u0660\7c\2\2\u0660\u0661\7f\2\2\u0661\u013e\3\2\2"+
+		"\2\u0662\u0663\7a\2\2\u0663\u0664\7a\2\2\u0664\u0665\7k\2\2\u0665\u0666"+
+		"\7u\2\2\u0666\u0667\7u\2\2\u0667\u0668\7g\2\2\u0668\u0669\7v\2\2\u0669"+
+		"\u0140\3\2\2\2\u066a\u066b\7a\2\2\u066b\u066c\7a\2\2\u066c\u066d\7w\2"+
+		"\2\u066d\u066e\7p\2\2\u066e\u066f\7u\2\2\u066f\u0670\7g\2\2\u0670\u0671"+
+		"\7v\2\2\u0671\u0142\3\2\2\2\u0672\u0673\7a\2\2\u0673\u0674\7a\2\2\u0674"+
+		"\u0675\7v\2\2\u0675\u0676\7q\2\2\u0676\u0677\7u\2\2\u0677\u0678\7v\2\2"+
+		"\u0678\u0679\7t\2\2\u0679\u067a\7k\2\2\u067a\u067b\7p\2\2\u067b\u067c"+
+		"\7i\2\2\u067c\u0144\3\2\2\2\u067d\u067e\7a\2\2\u067e\u067f\7a\2\2\u067f"+
+		"\u0680\7k\2\2\u0680\u0681\7p\2\2\u0681\u0682\7x\2\2\u0682\u0683\7q\2\2"+
+		"\u0683\u0684\7m\2\2\u0684\u0685\7g\2\2\u0685\u0146\3\2\2\2\u0686\u0687"+
+		"\7a\2\2\u0687\u0688\7a\2\2\u0688\u0689\7u\2\2\u0689\u068a\7g\2\2\u068a"+
+		"\u068b\7v\2\2\u068b\u068c\7a\2\2\u068c\u068d\7u\2\2\u068d\u068e\7v\2\2"+
+		"\u068e\u068f\7c\2\2\u068f\u0690\7v\2\2\u0690\u0691\7g\2\2\u0691\u0148"+
+		"\3\2\2\2\u0692\u0693\7a\2\2\u0693\u0694\7a\2\2\u0694\u0695\7e\2\2\u0695"+
+		"\u0696\7n\2\2\u0696\u0697\7q\2\2\u0697\u0698\7p\2\2\u0698\u0699\7g\2\2"+
+		"\u0699\u014a\3\2\2\2\u069a\u069b\7a\2\2\u069b\u069c\7a\2\2\u069c\u069d"+
+		"\7f\2\2\u069d\u069e\7g\2\2\u069e\u069f\7d\2\2\u069f\u06a0\7w\2\2\u06a0"+
+		"\u06a1\7i\2\2\u06a1\u06a2\7k\2\2\u06a2\u06a3\7p\2\2\u06a3\u06a4\7h\2\2"+
+		"\u06a4\u06a5\7q\2\2\u06a5\u014c\3\2\2\2\u06a6\u06a7\7a\2\2\u06a7\u06a8"+
+		"\7a\2\2\u06a8\u06a9\7p\2\2\u06a9\u06aa\7c\2\2\u06aa\u06ab\7o\2\2\u06ab"+
+		"\u06ac\7g\2\2\u06ac\u06ad\7u\2\2\u06ad\u06ae\7r\2\2\u06ae\u06af\7c\2\2"+
+		"\u06af\u06b0\7e\2\2\u06b0\u06b1\7g\2\2\u06b1\u06b2\7a\2\2\u06b2\u06b3"+
+		"\7a\2\2\u06b3\u014e\3\2\2\2\u06b4\u06b5\7a\2\2\u06b5\u06b6\7a\2\2\u06b6"+
+		"\u06b7\7e\2\2\u06b7\u06b8\7n\2\2\u06b8\u06b9\7c\2\2\u06b9\u06ba\7u\2\2"+
+		"\u06ba\u06bb\7u\2\2\u06bb\u06bc\7a\2\2\u06bc\u06bd\7a\2\2\u06bd\u0150"+
+		"\3\2\2\2\u06be\u06bf\7a\2\2\u06bf\u06c0\7a\2\2\u06c0\u06c1\7v\2\2\u06c1"+
+		"\u06c2\7t\2\2\u06c2\u06c3\7c\2\2\u06c3\u06c4\7k\2\2\u06c4\u06c5\7v\2\2"+
+		"\u06c5\u06c6\7a\2\2\u06c6\u06c7\7a\2\2\u06c7\u0152\3\2\2\2\u06c8\u06c9"+
+		"\7a\2\2\u06c9\u06ca\7a\2\2\u06ca\u06cb\7h\2\2\u06cb\u06cc\7w\2\2\u06cc"+
+		"\u06cd\7p\2\2\u06cd\u06ce\7e\2\2\u06ce\u06cf\7v\2\2\u06cf\u06d0\7k\2\2"+
+		"\u06d0\u06d1\7q\2\2\u06d1\u06d2\7p\2\2\u06d2\u06d3\7a\2\2\u06d3\u06d4"+
+		"\7a\2\2\u06d4\u0154\3\2\2\2\u06d5\u06d6\7a\2\2\u06d6\u06d7\7a\2\2\u06d7"+
+		"\u06d8\7o\2\2\u06d8\u06d9\7g\2\2\u06d9\u06da\7v\2\2\u06da\u06db\7j\2\2"+
+		"\u06db\u06dc\7q\2\2\u06dc\u06dd\7f\2\2\u06dd\u06de\7a\2\2\u06de\u06df"+
+		"\7a\2\2\u06df\u0156\3\2\2\2\u06e0\u06e1\7a\2\2\u06e1\u06e2\7a\2\2\u06e2"+
+		"\u06e3\7n\2\2\u06e3\u06e4\7k\2\2\u06e4\u06e5\7p\2\2\u06e5\u06e6\7g\2\2"+
+		"\u06e6\u06e7\7a\2\2\u06e7\u06e8\7a\2\2\u06e8\u0158\3\2\2\2\u06e9\u06ea"+
+		"\7a\2\2\u06ea\u06eb\7a\2\2\u06eb\u06ec\7h\2\2\u06ec\u06ed\7k\2\2\u06ed"+
+		"\u06ee\7n\2\2\u06ee\u06ef\7g\2\2\u06ef\u06f0\7a\2\2\u06f0\u06f1\7a\2\2"+
+		"\u06f1\u015a\3\2\2\2\u06f2\u06f3\7a\2\2\u06f3\u06f4\7a\2\2\u06f4\u06f5"+
+		"\7f\2\2\u06f5\u06f6\7k\2\2\u06f6\u06f7\7t\2\2\u06f7\u06f8\7a\2\2\u06f8"+
+		"\u06f9\7a\2\2\u06f9\u015c\3\2\2\2\u06fa\u06fb\7>\2\2\u06fb\u06fc\7?\2"+
+		"\2\u06fc\u06fd\7@\2\2\u06fd\u015e\3\2\2\2\u06fe\u06ff\7>\2\2\u06ff\u0700"+
+		"\7<\2\2\u0700\u0160\3\2\2\2\u0701\u0702\7<\2\2\u0702\u0703\7@\2\2\u0703"+
+		"\u0162\3\2\2\2\u0704\u0705\7?\2\2\u0705\u0706\7@\2\2\u0706\u0164\3\2\2"+
+		"\2\u0707\u0708\7-\2\2\u0708\u0709\7-\2\2\u0709\u0166\3\2\2\2\u070a\u070b"+
+		"\7/\2\2\u070b\u070c\7/\2\2\u070c\u0168\3\2\2\2\u070d\u070e\7?\2\2\u070e"+
+		"\u070f\7?\2\2\u070f\u0710\7?\2\2\u0710\u016a\3\2\2\2\u0711\u0712\7#\2"+
+		"\2\u0712\u0713\7?\2\2\u0713\u0714\7?\2\2\u0714\u016c\3\2\2\2\u0715\u0716"+
+		"\7?\2\2\u0716\u0717\7?\2\2\u0717\u016e\3\2\2\2\u0718\u0719\7>\2\2\u0719"+
+		"\u071d\7@\2\2\u071a\u071b\7#\2\2\u071b\u071d\7?\2\2\u071c\u0718\3\2\2"+
+		"\2\u071c\u071a\3\2\2\2\u071d\u0170\3\2\2\2\u071e\u071f\7>\2\2\u071f\u0720"+
+		"\7?\2\2\u0720\u0172\3\2\2\2\u0721\u0722\7@\2\2\u0722\u0723\7?\2\2\u0723"+
+		"\u0174\3\2\2\2\u0724\u0725\7-\2\2\u0725\u0726\7?\2\2\u0726\u0176\3\2\2"+
+		"\2\u0727\u0728\7/\2\2\u0728\u0729\7?\2\2\u0729\u0178\3\2\2\2\u072a\u072b"+
+		"\7,\2\2\u072b\u072c\7?\2\2\u072c\u017a\3\2\2\2\u072d\u072e\7,\2\2\u072e"+
+		"\u072f\7,\2\2\u072f\u017c\3\2\2\2\u0730\u0731\7,\2\2\u0731\u0732\7,\2"+
+		"\2\u0732\u0733\7?\2\2\u0733\u017e\3\2\2\2\u0734\u0735\7\61\2\2\u0735\u0736"+
+		"\7?\2\2\u0736\u0180\3\2\2\2\u0737\u0738\7\60\2\2\u0738\u0739\7?\2\2\u0739"+
+		"\u0182\3\2\2\2\u073a\u073b\7\'\2\2\u073b\u073c\7?\2\2\u073c\u0184\3\2"+
+		"\2\2\u073d\u073e\7>\2\2\u073e\u073f\7>\2\2\u073f\u0740\7?\2\2\u0740\u0186"+
+		"\3\2\2\2\u0741\u0742\7@\2\2\u0742\u0743\7@\2\2\u0743\u0744\7?\2\2\u0744"+
+		"\u0188\3\2\2\2\u0745\u0746\7(\2\2\u0746\u0747\7?\2\2\u0747\u018a\3\2\2"+
+		"\2\u0748\u0749\7~\2\2\u0749\u074a\7?\2\2\u074a\u018c\3\2\2\2\u074b\u074c"+
+		"\7`\2\2\u074c\u074d\7?\2\2\u074d\u018e\3\2\2\2\u074e\u074f\7~\2\2\u074f"+
+		"\u0750\7~\2\2\u0750\u0190\3\2\2\2\u0751\u0752\7(\2\2\u0752\u0753\7(\2"+
+		"\2\u0753\u0192\3\2\2\2\u0754\u0755\7A\2\2\u0755\u0756\7A\2\2\u0756\u0194"+
+		"\3\2\2\2\u0757\u0758\7A\2\2\u0758\u0759\7A\2\2\u0759\u075a\7?\2\2\u075a"+
+		"\u0196\3\2\2\2\u075b\u075c\7>\2\2\u075c\u075d\7>\2\2\u075d\u0198\3\2\2"+
+		"\2\u075e\u075f\7@\2\2\u075f\u0760\7@\2\2\u0760\u019a\3\2\2\2\u0761\u0762"+
+		"\7<\2\2\u0762\u0763\7<\2\2\u0763\u019c\3\2\2\2\u0764\u0765\7/\2\2\u0765"+
+		"\u0766\7@\2\2\u0766\u019e\3\2\2\2\u0767\u0768\7^\2\2\u0768\u01a0\3\2\2"+
+		"\2\u0769\u076a\7\60\2\2\u076a\u076b\7\60\2\2\u076b\u076c\7\60\2\2\u076c"+
+		"\u01a2\3\2\2\2\u076d\u076e\7>\2\2\u076e\u01a4\3\2\2\2\u076f\u0770\7@\2"+
+		"\2\u0770\u01a6\3\2\2\2\u0771\u0772\7(\2\2\u0772\u01a8\3\2\2\2\u0773\u0774"+
+		"\7~\2\2\u0774\u01aa\3\2\2\2\u0775\u0776\7#\2\2\u0776\u01ac\3\2\2\2\u0777"+
+		"\u0778\7`\2\2\u0778\u01ae\3\2\2\2\u0779\u077a\7-\2\2\u077a\u01b0\3\2\2"+
+		"\2\u077b\u077c\7/\2\2\u077c\u01b2\3\2\2\2\u077d\u077e\7,\2\2\u077e\u01b4"+
+		"\3\2\2\2\u077f\u0780\7\'\2\2\u0780\u01b6\3\2\2\2\u0781\u0782\7\61\2\2"+
+		"\u0782\u01b8\3\2\2\2\u0783\u0784\7\u0080\2\2\u0784\u01ba\3\2\2\2\u0785"+
+		"\u0786\7B\2\2\u0786\u01bc\3\2\2\2\u0787\u0788\7&\2\2\u0788\u01be\3\2\2"+
+		"\2\u0789\u078a\7\60\2\2\u078a\u01c0\3\2\2\2\u078b\u078c\7A\2\2\u078c\u01c2"+
+		"\3\2\2\2\u078d\u078e\7*\2\2\u078e\u01c4\3\2\2\2\u078f\u0790\7+\2\2\u0790"+
+		"\u01c6\3\2\2\2\u0791\u0792\7]\2\2\u0792\u01c8\3\2\2\2\u0793\u0794\7_\2"+
+		"\2\u0794\u01ca\3\2\2\2\u0795\u0796\7}\2\2\u0796\u01cc\3\2\2\2\u0797\u0798"+
+		"\7\177\2\2\u0798\u0799\b\u00e2\24\2\u0799\u01ce\3\2\2\2\u079a\u079b\7"+
+		".\2\2\u079b\u01d0\3\2\2\2\u079c\u079d\7<\2\2\u079d\u01d2\3\2\2\2\u079e"+
+		"\u079f\7=\2\2\u079f\u01d4\3\2\2\2\u07a0\u07a1\7?\2\2\u07a1\u01d6\3\2\2"+
+		"\2\u07a2\u07a3\7)\2\2\u07a3\u01d8\3\2\2\2\u07a4\u07a5\7b\2\2\u07a5\u01da"+
+		"\3\2\2\2\u07a6\u07a7\7&\2\2\u07a7\u07a8\5\u0213\u0105\2\u07a8\u01dc\3"+
+		"\2\2\2\u07a9\u07ad\t\t\2\2\u07aa\u07ac\t\n\2\2\u07ab\u07aa\3\2\2\2\u07ac"+
+		"\u07af\3\2\2\2\u07ad\u07ab\3\2\2\2\u07ad\u07ae\3\2\2\2\u07ae\u01de\3\2"+
+		"\2\2\u07af\u07ad\3\2\2\2\u07b0\u07b2\7\62\2\2\u07b1\u07b3\7q\2\2\u07b2"+
+		"\u07b1\3\2\2\2\u07b2\u07b3\3\2\2\2\u07b3\u07b5\3\2\2\2\u07b4\u07b6\5\u0221"+
+		"\u010c\2\u07b5\u07b4\3\2\2\2\u07b6\u07b7\3\2\2\2\u07b7\u07b5\3\2\2\2\u07b7"+
+		"\u07b8\3\2\2\2\u07b8\u07c1\3\2\2\2\u07b9\u07bb\7a\2\2\u07ba\u07bc\5\u0221"+
+		"\u010c\2\u07bb\u07ba\3\2\2\2\u07bc\u07bd\3\2\2\2\u07bd\u07bb\3\2\2\2\u07bd"+
+		"\u07be\3\2\2\2\u07be\u07c0\3\2\2\2\u07bf\u07b9\3\2\2\2\u07c0\u07c3\3\2"+
+		"\2\2\u07c1\u07bf\3\2\2\2\u07c1\u07c2\3\2\2\2\u07c2\u01e0\3\2\2\2\u07c3"+
+		"\u07c1\3\2\2\2\u07c4\u07d8\7\62\2\2\u07c5\u07c9\5\u021d\u010a\2\u07c6"+
+		"\u07c8\5\u021f\u010b\2\u07c7\u07c6\3\2\2\2\u07c8\u07cb\3\2\2\2\u07c9\u07c7"+
+		"\3\2\2\2\u07c9\u07ca\3\2\2\2\u07ca\u07d4\3\2\2\2\u07cb\u07c9\3\2\2\2\u07cc"+
+		"\u07ce\7a\2\2\u07cd\u07cf\5\u021f\u010b\2\u07ce\u07cd\3\2\2\2\u07cf\u07d0"+
+		"\3\2\2\2\u07d0\u07ce\3\2\2\2\u07d0\u07d1\3\2\2\2\u07d1\u07d3\3\2\2\2\u07d2"+
+		"\u07cc\3\2\2\2\u07d3\u07d6\3\2\2\2\u07d4\u07d2\3\2\2\2\u07d4\u07d5\3\2"+
+		"\2\2\u07d5\u07d8\3\2\2\2\u07d6\u07d4\3\2\2\2\u07d7\u07c4\3\2\2\2\u07d7"+
+		"\u07c5\3\2\2\2\u07d8\u01e2\3\2\2\2\u07d9\u07da\5\u0219\u0108\2\u07da\u07dc"+
+		"\7\60\2\2\u07db\u07dd\5\u0219\u0108\2\u07dc\u07db\3\2\2\2\u07dc\u07dd"+
+		"\3\2\2\2\u07dd\u07e4\3\2\2\2\u07de\u07e0\5\u0219\u0108\2\u07df\u07de\3"+
+		"\2\2\2\u07df\u07e0\3\2\2\2\u07e0\u07e1\3\2\2\2\u07e1\u07e2\7\60\2\2\u07e2"+
+		"\u07e4\5\u0219\u0108\2\u07e3\u07d9\3\2\2\2\u07e3\u07df\3\2\2\2\u07e4\u07e6"+
+		"\3\2\2\2\u07e5\u07e7\5\u021b\u0109\2\u07e6\u07e5\3\2\2\2\u07e6\u07e7\3"+
+		"\2\2\2\u07e7\u07f0\3\2\2\2\u07e8\u07ea\5\u0219\u0108\2\u07e9\u07e8\3\2"+
+		"\2\2\u07ea\u07eb\3\2\2\2\u07eb\u07e9\3\2\2\2\u07eb\u07ec\3\2\2\2\u07ec"+
+		"\u07ed\3\2\2\2\u07ed\u07ee\5\u021b\u0109\2\u07ee\u07f0\3\2\2\2\u07ef\u07e3"+
+		"\3\2\2\2\u07ef\u07e9\3\2\2\2\u07f0\u01e4\3\2\2\2\u07f1\u07f2\7\62\2\2"+
+		"\u07f2\u07f3\7z\2\2\u07f3\u07f5\3\2\2\2\u07f4\u07f6\5\u0223\u010d\2\u07f5"+
+		"\u07f4\3\2\2\2\u07f6\u07f7\3\2\2\2\u07f7\u07f5\3\2\2\2\u07f7\u07f8\3\2"+
+		"\2\2\u07f8\u0801\3\2\2\2\u07f9\u07fb\7a\2\2\u07fa\u07fc\5\u0223\u010d"+
+		"\2\u07fb\u07fa\3\2\2\2\u07fc\u07fd\3\2\2\2\u07fd\u07fb\3\2\2\2\u07fd\u07fe"+
+		"\3\2\2\2\u07fe\u0800\3\2\2\2\u07ff\u07f9\3\2\2\2\u0800\u0803\3\2\2\2\u0801"+
+		"\u07ff\3\2\2\2\u0801\u0802\3\2\2\2\u0802\u01e6\3\2\2\2\u0803\u0801\3\2"+
+		"\2\2\u0804\u0805\7\62\2\2\u0805\u0806\7d\2\2\u0806\u0808\3\2\2\2\u0807"+
+		"\u0809\t\13\2\2\u0808\u0807\3\2\2\2\u0809\u080a\3\2\2\2\u080a\u0808\3"+
+		"\2\2\2\u080a\u080b\3\2\2\2\u080b\u0814\3\2\2\2\u080c\u080e\7a\2\2\u080d"+
+		"\u080f\t\13\2\2\u080e\u080d\3\2\2\2\u080f\u0810\3\2\2\2\u0810\u080e\3"+
+		"\2\2\2\u0810\u0811\3\2\2\2\u0811\u0813\3\2\2\2\u0812\u080c\3\2\2\2\u0813"+
+		"\u0816\3\2\2\2\u0814\u0812\3\2\2\2\u0814\u0815\3\2\2\2\u0815\u01e8\3\2"+
+		"\2\2\u0816\u0814\3\2\2\2\u0817\u081b\7b\2\2\u0818\u081a\n\f\2\2\u0819"+
+		"\u0818\3\2\2\2\u081a\u081d\3\2\2\2\u081b\u0819\3\2\2\2\u081b\u081c\3\2"+
+		"\2\2\u081c\u081e\3\2\2\2\u081d\u081b\3\2\2\2\u081e\u081f\7b\2\2\u081f"+
+		"\u01ea\3\2\2\2\u0820\u0826\7)\2\2\u0821\u0825\n\r\2\2\u0822\u0823\7^\2"+
+		"\2\u0823\u0825\13\2\2\2\u0824\u0821\3\2\2\2\u0824\u0822\3\2\2\2\u0825"+
+		"\u0828\3\2\2\2\u0826\u0824\3\2\2\2\u0826\u0827\3\2\2\2\u0827\u0829\3\2"+
+		"\2\2\u0828\u0826\3\2\2\2\u0829\u082a\7)\2\2\u082a\u01ec\3\2\2\2\u082b"+
+		"\u082c\7$\2\2\u082c\u082d\3\2\2\2\u082d\u082e\b\u00f2\25\2\u082e\u01ee"+
+		"\3\2\2\2\u082f\u0830\7>\2\2\u0830\u0831\7>\2\2\u0831\u0832\7>\2\2\u0832"+
+		"\u0836\3\2\2\2\u0833\u0835\t\16\2\2\u0834\u0833\3\2\2\2\u0835\u0838\3"+
+		"\2\2\2\u0836\u0834\3\2\2\2\u0836\u0837\3\2\2\2\u0837\u0839\3\2\2\2\u0838"+
+		"\u0836\3\2\2\2\u0839\u083a\7)\2\2\u083a\u083b\5\u0213\u0105\2\u083b\u083c"+
+		"\7)\2\2\u083c\u083d\6\u00f3\5\2\u083d\u083e\3\2\2\2\u083e\u083f\b\u00f3"+
+		"\26\2\u083f\u01f0\3\2\2\2\u0840\u0841\7>\2\2\u0841\u0842\7>\2\2\u0842"+
+		"\u0843\7>\2\2\u0843\u0847\3\2\2\2\u0844\u0846\t\16\2\2\u0845\u0844\3\2"+
+		"\2\2\u0846\u0849\3\2\2\2\u0847\u0845\3\2\2\2\u0847\u0848\3\2\2\2\u0848"+
+		"\u084a\3\2\2\2\u0849\u0847\3\2\2\2\u084a\u084b\5\u0213\u0105\2\u084b\u084c"+
+		"\6\u00f4\6\2\u084c\u084d\3\2\2\2\u084d\u084e\b\u00f4\26\2\u084e\u01f2"+
+		"\3\2\2\2\u084f\u0850\13\2\2\2\u0850\u0851\3\2\2\2\u0851\u0852\b\u00f5"+
+		"\13\2\u0852\u01f4\3\2\2\2\u0853\u0854\7&\2\2\u0854\u0855\5\u0213\u0105"+
+		"\2\u0855\u0856\3\2\2\2\u0856\u0857\b\u00f6\27\2\u0857\u01f6\3\2\2\2\u0858"+
+		"\u0859\7&\2\2\u0859\u085a\3\2\2\2\u085a\u085b\b\u00f7\30\2\u085b\u01f8"+
+		"\3\2\2\2\u085c\u085d\7}\2\2\u085d\u085e\6\u00f8\7\2\u085e\u085f\b\u00f8"+
+		"\31\2\u085f\u0860\3\2\2\2\u0860\u0861\b\u00f8\6\2\u0861\u0862\b\u00f8"+
+		"\5\2\u0862\u01fa\3\2\2\2\u0863\u0864\7}\2\2\u0864\u0865\3\2\2\2\u0865"+
+		"\u0866\b\u00f9\30\2\u0866\u01fc\3\2\2\2\u0867\u0868\7^\2\2\u0868\u0869"+
+		"\13\2\2\2\u0869\u086a\3\2\2\2\u086a\u086b\b\u00fa\30\2\u086b\u01fe\3\2"+
+		"\2\2\u086c\u086d\7$\2\2\u086d\u086e\3\2\2\2\u086e\u086f\b\u00fb\32\2\u086f"+
+		"\u0870\b\u00fb\f\2\u0870\u0200\3\2\2\2\u0871\u0872\7^\2\2\u0872\u0873"+
+		"\7w\2\2\u0873\u0874\7}\2\2\u0874\u0875\3\2\2\2\u0875\u0877\t\17\2\2\u0876"+
+		"\u0878\t\17\2\2\u0877\u0876\3\2\2\2\u0878\u0879\3\2\2\2\u0879\u0877\3"+
+		"\2\2\2\u0879\u087a\3\2\2\2\u087a\u087b\3\2\2\2\u087b\u087c\7\177\2\2\u087c"+
+		"\u0202\3\2\2\2\u087d\u087f\n\20\2\2\u087e\u087d\3\2\2\2\u087f\u0880\3"+
+		"\2\2\2\u0880\u087e\3\2\2\2\u0880\u0881\3\2\2\2\u0881\u0204\3\2\2\2\u0882"+
+		"\u0884\n\21\2\2\u0883\u0882\3\2\2\2\u0884\u0885\3\2\2\2\u0885\u0883\3"+
+		"\2\2\2\u0885\u0886\3\2\2\2\u0886\u0887\3\2\2\2\u0887\u0888\b\u00fe\22"+
+		"\2\u0888\u0206\3\2\2\2\u0889\u088a\7A\2\2\u088a\u088b\7@\2\2\u088b\u0208"+
+		"\3\2\2\2\u088c\u088d\7A\2\2\u088d\u088e\3\2\2\2\u088e\u088f\b\u0100\33"+
+		"\2\u088f\u0890\b\u0100\22\2\u0890\u020a\3\2\2\2\u0891\u0892\t\4\2\2\u0892"+
+		"\u0893\3\2\2\2\u0893\u0894\b\u0101\6\2\u0894\u0895\b\u0101\f\2\u0895\u020c"+
+		"\3\2\2\2\u0896\u0898\n\4\2\2\u0897\u0896\3\2\2\2\u0898\u089b\3\2\2\2\u0899"+
+		"\u089a\3\2\2\2\u0899\u0897\3\2\2\2\u089a\u08a1\3\2\2\2\u089b\u0899\3\2"+
+		"\2\2\u089c\u089e\7\17\2\2\u089d\u089c\3\2\2\2\u089d\u089e\3\2\2\2\u089e"+
+		"\u089f\3\2\2\2\u089f\u08a2\7\f\2\2\u08a0\u08a2\7\17\2\2\u08a1\u089d\3"+
+		"\2\2\2\u08a1\u08a0\3\2\2\2\u08a2\u020e\3\2\2\2\u08a3\u08a9\7>\2\2\u08a4"+
+		"\u08a5\7A\2\2\u08a5\u08aa\7?\2\2\u08a6\u08a7\6\u0103\b\2\u08a7\u08a8\7"+
+		"\'\2\2\u08a8\u08aa\7?\2\2\u08a9\u08a4\3\2\2\2\u08a9\u08a6\3\2\2\2\u08aa"+
+		"\u0210\3\2\2\2\u08ab\u08b4\7>\2\2\u08ac\u08b0\7A\2\2\u08ad\u08ae\7r\2"+
+		"\2\u08ae\u08af\7j\2\2\u08af\u08b1\7r\2\2\u08b0\u08ad\3\2\2\2\u08b0\u08b1"+
+		"\3\2\2\2\u08b1\u08b5\3\2\2\2\u08b2\u08b3\6\u0104\t\2\u08b3\u08b5\7\'\2"+
+		"\2\u08b4\u08ac\3\2\2\2\u08b4\u08b2\3\2\2\2\u08b5\u0212\3\2\2\2\u08b6\u08ba"+
+		"\t\22\2\2\u08b7\u08b9\t\23\2\2\u08b8\u08b7\3\2\2\2\u08b9\u08bc\3\2\2\2"+
+		"\u08ba\u08b8\3\2\2\2\u08ba\u08bb\3\2\2\2\u08bb\u0214\3\2\2\2\u08bc\u08ba"+
+		"\3\2\2\2\u08bd\u08c2\5\u0217\u0107\2\u08be\u08c2\t\24\2\2\u08bf\u08c2"+
+		"\5\u021f\u010b\2\u08c0\u08c2\t\25\2\2\u08c1\u08bd\3\2\2\2\u08c1\u08be"+
+		"\3\2\2\2\u08c1\u08bf\3\2\2\2\u08c1\u08c0\3\2\2\2\u08c2\u0216\3\2\2\2\u08c3"+
+		"\u08c5\t\26\2\2\u08c4\u08c3\3\2\2\2\u08c5\u0218\3\2\2\2\u08c6\u08c8\5"+
+		"\u021f\u010b\2\u08c7\u08c6\3\2\2\2\u08c8\u08c9\3\2\2\2\u08c9\u08c7\3\2"+
+		"\2\2\u08c9\u08ca\3\2\2\2\u08ca\u08d3\3\2\2\2\u08cb\u08cd\7a\2\2\u08cc"+
+		"\u08ce\5\u021f\u010b\2\u08cd\u08cc\3\2\2\2\u08ce\u08cf\3\2\2\2\u08cf\u08cd"+
+		"\3\2\2\2\u08cf\u08d0\3\2\2\2\u08d0\u08d2\3\2\2\2\u08d1\u08cb\3\2\2\2\u08d2"+
+		"\u08d5\3\2\2\2\u08d3\u08d1\3\2\2\2\u08d3\u08d4\3\2\2\2\u08d4\u021a\3\2"+
+		"\2\2\u08d5\u08d3\3\2\2\2\u08d6\u08d8\7g\2\2\u08d7\u08d9\t\27\2\2\u08d8"+
+		"\u08d7\3\2\2\2\u08d8\u08d9\3\2\2\2\u08d9\u08da\3\2\2\2\u08da\u08db\5\u0219"+
+		"\u0108\2\u08db\u021c\3\2\2\2\u08dc\u08dd\t\30\2\2\u08dd\u021e\3\2\2\2"+
+		"\u08de\u08df\t\31\2\2\u08df\u0220\3\2\2\2\u08e0\u08e1\t\32\2\2\u08e1\u0222"+
+		"\3\2\2\2\u08e2\u08e3\t\33\2\2\u08e3\u0224\3\2\2\2U\2\3\4\5\6\7\b\t\n\13"+
+		"\f\u0228\u022f\u0263\u0272\u0281\u0288\u0294\u02b6\u02bd\u02c7\u02cc\u02d1"+
+		"\u02d9\u02ec\u02f3\u0305\u030c\u0315\u0320\u0337\u0342\u034b\u0359\u035e"+
+		"\u0368\u039f\u03aa\u04f0\u05c7\u071c\u07ad\u07b2\u07b7\u07bd\u07c1\u07c9"+
+		"\u07d0\u07d4\u07d7\u07dc\u07df\u07e3\u07e6\u07eb\u07ef\u07f7\u07fd\u0801"+
+		"\u080a\u0810\u0814\u081b\u0824\u0826\u0836\u0847\u0879\u0880\u0885\u0899"+
+		"\u089d\u08a1\u08a9\u08b0\u08b4\u08ba\u08c1\u08c4\u08c9\u08cf\u08d3\u08d8"+
+		"\34\2\3\2\7\3\2\tA\2\7\t\2\2\6\2\3\7\2\7\4\2\3\b\3\5\2\2\2\5\2\6\2\2\t"+
+		"\16\2\3\24\4\7\5\2\7\6\2\t$\2\2\4\2\7\13\2\3\u00e2\5\7\n\2\7\f\2\t\u00e2"+
+		"\2\t\u00f1\2\3\u00f8\6\t\u00eb\2\t\u00f2\2";
+	public static final ATN _ATN =
+		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
+	static {
+		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
+		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
+			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
+		}
+	}
+}
\ No newline at end of file
diff --git a/app/src/main/java/antlr/PhpLexer.tokens b/app/src/main/java/antlr/PhpLexer.tokens
new file mode 100644
index 0000000000000000000000000000000000000000..67693cc29a5a6fd4e9d85800def2113c4253c5ab
--- /dev/null
+++ b/app/src/main/java/antlr/PhpLexer.tokens
@@ -0,0 +1,416 @@
+SeaWhitespace=1
+HtmlText=2
+XmlStart=3
+PHPStart=4
+HtmlScriptOpen=5
+HtmlStyleOpen=6
+HtmlComment=7
+HtmlDtd=8
+HtmlOpen=9
+Shebang=10
+Error=11
+XmlText=12
+XmlClose=13
+PHPStartInside=14
+HtmlClose=15
+HtmlSlashClose=16
+HtmlSlash=17
+HtmlEquals=18
+HtmlStartQuoteString=19
+HtmlStartDoubleQuoteString=20
+HtmlHex=21
+HtmlDecimal=22
+HtmlSpace=23
+HtmlName=24
+ErrorInside=25
+PHPStartInsideQuoteString=26
+HtmlEndQuoteString=27
+HtmlQuoteString=28
+ErrorHtmlQuote=29
+PHPStartDoubleQuoteString=30
+HtmlEndDoubleQuoteString=31
+HtmlDoubleQuoteString=32
+ErrorHtmlDoubleQuote=33
+ScriptText=34
+HtmlScriptClose=35
+PHPStartInsideScript=36
+StyleBody=37
+PHPEnd=38
+Whitespace=39
+MultiLineComment=40
+SingleLineComment=41
+ShellStyleComment=42
+AttributeStart=43
+Abstract=44
+Array=45
+As=46
+BinaryCast=47
+BoolType=48
+BooleanConstant=49
+Break=50
+Callable=51
+Case=52
+Catch=53
+Class=54
+Clone=55
+Const=56
+Continue=57
+Declare=58
+Default=59
+Do=60
+DoubleCast=61
+DoubleType=62
+Echo=63
+Else=64
+ElseIf=65
+Empty=66
+Enum_=67
+EndDeclare=68
+EndFor=69
+EndForeach=70
+EndIf=71
+EndSwitch=72
+EndWhile=73
+Eval=74
+Exit=75
+Extends=76
+Final=77
+Finally=78
+FloatCast=79
+For=80
+Foreach=81
+Function_=82
+Global=83
+Goto=84
+If=85
+Implements=86
+Import=87
+Include=88
+IncludeOnce=89
+InstanceOf=90
+InsteadOf=91
+Int8Cast=92
+Int16Cast=93
+Int64Type=94
+IntType=95
+Interface=96
+IsSet=97
+List=98
+LogicalAnd=99
+LogicalOr=100
+LogicalXor=101
+Match_=102
+Namespace=103
+New=104
+Null=105
+ObjectType=106
+Parent_=107
+Partial=108
+Print=109
+Private=110
+Protected=111
+Public=112
+Readonly=113
+Require=114
+RequireOnce=115
+Resource=116
+Return=117
+Static=118
+StringType=119
+Switch=120
+Throw=121
+Trait=122
+Try=123
+Typeof=124
+UintCast=125
+UnicodeCast=126
+Unset=127
+Use=128
+Var=129
+While=130
+Yield=131
+From=132
+LambdaFn=133
+Ticks=134
+Encoding=135
+StrictTypes=136
+Get=137
+Set=138
+Call=139
+CallStatic=140
+Constructor=141
+Destruct=142
+Wakeup=143
+Sleep=144
+Autoload=145
+IsSet__=146
+Unset__=147
+ToString__=148
+Invoke=149
+SetState=150
+Clone__=151
+DebugInfo=152
+Namespace__=153
+Class__=154
+Traic__=155
+Function__=156
+Method__=157
+Line__=158
+File__=159
+Dir__=160
+Spaceship=161
+Lgeneric=162
+Rgeneric=163
+DoubleArrow=164
+Inc=165
+Dec=166
+IsIdentical=167
+IsNoidentical=168
+IsEqual=169
+IsNotEq=170
+IsSmallerOrEqual=171
+IsGreaterOrEqual=172
+PlusEqual=173
+MinusEqual=174
+MulEqual=175
+Pow=176
+PowEqual=177
+DivEqual=178
+Concaequal=179
+ModEqual=180
+ShiftLeftEqual=181
+ShiftRightEqual=182
+AndEqual=183
+OrEqual=184
+XorEqual=185
+BooleanOr=186
+BooleanAnd=187
+NullCoalescing=188
+NullCoalescingEqual=189
+ShiftLeft=190
+ShiftRight=191
+DoubleColon=192
+ObjectOperator=193
+NamespaceSeparator=194
+Ellipsis=195
+Less=196
+Greater=197
+Ampersand=198
+Pipe=199
+Bang=200
+Caret=201
+Plus=202
+Minus=203
+Asterisk=204
+Percent=205
+Divide=206
+Tilde=207
+SuppressWarnings=208
+Dollar=209
+Dot=210
+QuestionMark=211
+OpenRoundBracket=212
+CloseRoundBracket=213
+OpenSquareBracket=214
+CloseSquareBracket=215
+OpenCurlyBracket=216
+CloseCurlyBracket=217
+Comma=218
+Colon=219
+SemiColon=220
+Eq=221
+Quote=222
+BackQuote=223
+VarName=224
+Label=225
+Octal=226
+Decimal=227
+Real=228
+Hex=229
+Binary=230
+BackQuoteString=231
+SingleQuoteString=232
+DoubleQuote=233
+StartNowDoc=234
+StartHereDoc=235
+ErrorPhp=236
+CurlyDollar=237
+UnicodeEscape=238
+StringPart=239
+Comment=240
+PHPEndSingleLineComment=241
+CommentEnd=242
+HereDocText=243
+XmlText2=244
+'<?xml'=3
+'?>'=13
+'/>'=16
+'#['=43
+'abstract'=44
+'array'=45
+'as'=46
+'binary'=47
+'break'=50
+'callable'=51
+'case'=52
+'catch'=53
+'class'=54
+'clone'=55
+'const'=56
+'continue'=57
+'declare'=58
+'default'=59
+'do'=60
+'real'=61
+'double'=62
+'echo'=63
+'else'=64
+'elseif'=65
+'empty'=66
+'enum'=67
+'enddeclare'=68
+'endfor'=69
+'endforeach'=70
+'endif'=71
+'endswitch'=72
+'endwhile'=73
+'eval'=74
+'die'=75
+'extends'=76
+'final'=77
+'finally'=78
+'float'=79
+'for'=80
+'foreach'=81
+'function'=82
+'global'=83
+'goto'=84
+'if'=85
+'implements'=86
+'import'=87
+'include'=88
+'include_once'=89
+'instanceof'=90
+'insteadof'=91
+'int8'=92
+'int16'=93
+'int64'=94
+'interface'=96
+'isset'=97
+'list'=98
+'and'=99
+'or'=100
+'xor'=101
+'match'=102
+'namespace'=103
+'new'=104
+'null'=105
+'object'=106
+'parent'=107
+'partial'=108
+'print'=109
+'private'=110
+'protected'=111
+'public'=112
+'readonly'=113
+'require'=114
+'require_once'=115
+'resource'=116
+'return'=117
+'static'=118
+'string'=119
+'switch'=120
+'throw'=121
+'trait'=122
+'try'=123
+'clrtypeof'=124
+'unicode'=126
+'unset'=127
+'use'=128
+'var'=129
+'while'=130
+'yield'=131
+'from'=132
+'fn'=133
+'ticks'=134
+'encoding'=135
+'strict_types'=136
+'__get'=137
+'__set'=138
+'__call'=139
+'__callstatic'=140
+'__construct'=141
+'__destruct'=142
+'__wakeup'=143
+'__sleep'=144
+'__autoload'=145
+'__isset'=146
+'__unset'=147
+'__tostring'=148
+'__invoke'=149
+'__set_state'=150
+'__clone'=151
+'__debuginfo'=152
+'__namespace__'=153
+'__class__'=154
+'__trait__'=155
+'__function__'=156
+'__method__'=157
+'__line__'=158
+'__file__'=159
+'__dir__'=160
+'<=>'=161
+'<:'=162
+':>'=163
+'=>'=164
+'++'=165
+'--'=166
+'==='=167
+'!=='=168
+'=='=169
+'<='=171
+'>='=172
+'+='=173
+'-='=174
+'*='=175
+'**'=176
+'**='=177
+'/='=178
+'.='=179
+'%='=180
+'<<='=181
+'>>='=182
+'&='=183
+'|='=184
+'^='=185
+'||'=186
+'&&'=187
+'??'=188
+'??='=189
+'<<'=190
+'>>'=191
+'::'=192
+'->'=193
+'\\'=194
+'...'=195
+'&'=198
+'|'=199
+'!'=200
+'^'=201
+'+'=202
+'-'=203
+'*'=204
+'%'=205
+'~'=207
+'@'=208
+'.'=210
+'('=212
+')'=213
+'['=214
+']'=215
+'}'=217
+','=218
+':'=219
+';'=220
+'\''=222
+'`'=223
diff --git a/app/src/main/java/antlr/PhpLexerBase.java b/app/src/main/java/antlr/PhpLexerBase.java
new file mode 100644
index 0000000000000000000000000000000000000000..ecb835d845bf146acd542acd125b12f785dc5ca0
--- /dev/null
+++ b/app/src/main/java/antlr/PhpLexerBase.java
@@ -0,0 +1,193 @@
+package antlr;
+
+/*
+PHP grammar.
+The MIT License (MIT).
+Copyright (c) 2015-2019, Ivan Kochurkin (kvanttt@gmail.com), Positive Technologies.
+Copyright (c) 2019, Thierry Marianne (thierry.marianne@weaving-the-web.org)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+import org.antlr.v4.runtime.*;
+
+public abstract class PhpLexerBase extends Lexer
+{
+    protected boolean AspTags = true;
+    protected boolean _scriptTag;
+    protected boolean _styleTag;
+    protected String _heredocIdentifier;
+    protected int _prevTokenType;
+    protected String _htmlNameText;
+    protected boolean _phpScript;
+    protected boolean _insideString;
+
+    public PhpLexerBase(CharStream input) {
+        super(input);
+    }
+
+    @Override
+    public Token nextToken() {
+        CommonToken token = (CommonToken)super.nextToken();
+
+        if (token.getType() == PhpLexer.PHPEnd || token.getType() == PhpLexer.PHPEndSingleLineComment)
+        {
+            if (_mode == PhpLexer.SingleLineCommentMode)
+            {
+                // SingleLineCommentMode for such allowed syntax:
+                // <?php echo "Hello world"; // comment ?>
+                popMode(); // exit from SingleLineComment mode.
+            }
+            popMode(); // exit from PHP mode.
+
+            if ("</script>".equals(token.getText()))
+            {
+                _phpScript = false;
+                token.setType(PhpLexer.HtmlScriptClose);
+            }
+            else
+            {
+                // Add semicolon to the end of statement if it is absente.
+                // For example: <?php echo "Hello world" ?>
+                if (_prevTokenType == PhpLexer.SemiColon || _prevTokenType == PhpLexer.Colon
+                        || _prevTokenType == PhpLexer.OpenCurlyBracket || _prevTokenType == PhpLexer.CloseCurlyBracket)
+                {
+                    token.setChannel(PhpLexer.SkipChannel);
+                }
+                else
+                {
+                    token.setType(PhpLexer.SemiColon);
+                }
+            }
+        }
+        else if (token.getType() == PhpLexer.HtmlName)
+        {
+            _htmlNameText = token.getText();
+        }
+        else if (token.getType() == PhpLexer.HtmlDoubleQuoteString)
+        {
+            if ("php".equals(token.getText()) && "language".equals(_htmlNameText))
+            {
+                _phpScript = true;
+            }
+        }
+        else if (_mode == PhpLexer.HereDoc)
+        {
+            // Heredoc and Nowdoc syntax support: http://php.net/manual/en/language.types.string.php#language.types.string.syntax.heredoc
+            switch (token.getType())
+            {
+                case PhpLexer.StartHereDoc:
+                case PhpLexer.StartNowDoc:
+                    _heredocIdentifier = token.getText().substring(3).trim().replace("'","");
+                    break;
+
+                case PhpLexer.HereDocText:
+                    if (CheckHeredocEnd(token.getText()))
+                    {
+                        popMode();
+
+                        String heredocIdentifier = GetHeredocIdentifier(token.getText());
+                        if (token.getText().trim().endsWith(";"))
+                        {
+                            token = new CommonToken(PhpLexer.SemiColon, heredocIdentifier + ";\n");
+                        }
+                        else
+                        {
+                            token = (CommonToken)super.nextToken();
+                            token.setText(heredocIdentifier + "\n;");
+                        }
+                    }
+                    break;
+            }
+        }
+        else if (_mode == PhpLexer.PHP)
+        {
+            if (_channel != PhpLexer.HIDDEN)
+            {
+                _prevTokenType = token.getType();
+            }
+        }
+
+        return token;
+    }
+
+    private String GetHeredocIdentifier(String text) {
+        String trimmedText = text.trim();
+        boolean semi = (trimmedText.length() > 0) ? (trimmedText.charAt(trimmedText.length() - 1) == ';') : false;
+        return semi ? trimmedText.substring(0, trimmedText.length() - 1) : trimmedText;
+    }
+
+    private boolean CheckHeredocEnd(String text) {
+        return GetHeredocIdentifier(text).equals(_heredocIdentifier);
+    }
+
+    protected boolean IsNewLineOrStart(int pos) {
+        return this._input.LA(pos) <= 0 || this._input.LA(pos) == '\r' || this._input.LA(pos) == '\n';
+    }
+
+    protected void PushModeOnHtmlClose() {
+        popMode();
+        if (_scriptTag)
+        {
+            if (!_phpScript)
+            {
+                pushMode(PhpLexer.SCRIPT);
+            }
+            else
+            {
+                pushMode(PhpLexer.PHP);
+            }
+            _scriptTag = false;
+        }
+        else if (_styleTag)
+        {
+            pushMode(PhpLexer.STYLE);
+            _styleTag = false;
+        }
+    }
+
+    protected boolean HasAspTags() {
+        return this.AspTags;
+    }
+
+    protected boolean HasPhpScriptTag() {
+        return this._phpScript;
+    }
+
+    protected void PopModeOnCurlyBracketClose() {
+        if (_insideString)
+        {
+            _insideString = false;
+            setChannel(PhpLexer.SkipChannel);
+            popMode();
+        }
+    }
+
+    protected boolean ShouldPushHereDocMode(int pos) {
+        return _input.LA(pos) == '\r' || _input.LA(pos) == '\n';
+    }
+
+    protected boolean IsCurlyDollar(int pos) {
+        return _input.LA(pos) == '$';
+    }
+
+    protected void SetInsideString() {
+        _insideString = true;
+    }
+}
diff --git a/app/src/main/java/antlr/PhpParser.java b/app/src/main/java/antlr/PhpParser.java
new file mode 100644
index 0000000000000000000000000000000000000000..c3c73534248cd71364e1a78cae817aeece0d5c38
--- /dev/null
+++ b/app/src/main/java/antlr/PhpParser.java
@@ -0,0 +1,14675 @@
+package antlr;
+
+// Generated from PhpParser.g4 by ANTLR 4.5
+import org.antlr.v4.runtime.atn.*;
+import org.antlr.v4.runtime.dfa.DFA;
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.misc.*;
+import org.antlr.v4.runtime.tree.*;
+import java.util.List;
+import java.util.Iterator;
+import java.util.ArrayList;
+
+@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
+public class PhpParser extends Parser {
+	static { RuntimeMetaData.checkVersion("4.5", RuntimeMetaData.VERSION); }
+
+	protected static final DFA[] _decisionToDFA;
+	protected static final PredictionContextCache _sharedContextCache =
+		new PredictionContextCache();
+	public static final int
+		SeaWhitespace=1, HtmlText=2, XmlStart=3, PHPStart=4, HtmlScriptOpen=5, 
+		HtmlStyleOpen=6, HtmlComment=7, HtmlDtd=8, HtmlOpen=9, Shebang=10, Error=11, 
+		XmlText=12, XmlClose=13, PHPStartInside=14, HtmlClose=15, HtmlSlashClose=16, 
+		HtmlSlash=17, HtmlEquals=18, HtmlStartQuoteString=19, HtmlStartDoubleQuoteString=20, 
+		HtmlHex=21, HtmlDecimal=22, HtmlSpace=23, HtmlName=24, ErrorInside=25, 
+		PHPStartInsideQuoteString=26, HtmlEndQuoteString=27, HtmlQuoteString=28, 
+		ErrorHtmlQuote=29, PHPStartDoubleQuoteString=30, HtmlEndDoubleQuoteString=31, 
+		HtmlDoubleQuoteString=32, ErrorHtmlDoubleQuote=33, ScriptText=34, HtmlScriptClose=35, 
+		PHPStartInsideScript=36, StyleBody=37, PHPEnd=38, Whitespace=39, MultiLineComment=40, 
+		SingleLineComment=41, ShellStyleComment=42, AttributeStart=43, Abstract=44, 
+		Array=45, As=46, BinaryCast=47, BoolType=48, BooleanConstant=49, Break=50, 
+		Callable=51, Case=52, Catch=53, Class=54, Clone=55, Const=56, Continue=57, 
+		Declare=58, Default=59, Do=60, DoubleCast=61, DoubleType=62, Echo=63, 
+		Else=64, ElseIf=65, Empty=66, Enum_=67, EndDeclare=68, EndFor=69, EndForeach=70, 
+		EndIf=71, EndSwitch=72, EndWhile=73, Eval=74, Exit=75, Extends=76, Final=77, 
+		Finally=78, FloatCast=79, For=80, Foreach=81, Function_=82, Global=83, 
+		Goto=84, If=85, Implements=86, Import=87, Include=88, IncludeOnce=89, 
+		InstanceOf=90, InsteadOf=91, Int8Cast=92, Int16Cast=93, Int64Type=94, 
+		IntType=95, Interface=96, IsSet=97, List=98, LogicalAnd=99, LogicalOr=100, 
+		LogicalXor=101, Match_=102, Namespace=103, New=104, Null=105, ObjectType=106, 
+		Parent_=107, Partial=108, Print=109, Private=110, Protected=111, Public=112, 
+		Readonly=113, Require=114, RequireOnce=115, Resource=116, Return=117, 
+		Static=118, StringType=119, Switch=120, Throw=121, Trait=122, Try=123, 
+		Typeof=124, UintCast=125, UnicodeCast=126, Unset=127, Use=128, Var=129, 
+		While=130, Yield=131, From=132, LambdaFn=133, Ticks=134, Encoding=135, 
+		StrictTypes=136, Get=137, Set=138, Call=139, CallStatic=140, Constructor=141, 
+		Destruct=142, Wakeup=143, Sleep=144, Autoload=145, IsSet__=146, Unset__=147, 
+		ToString__=148, Invoke=149, SetState=150, Clone__=151, DebugInfo=152, 
+		Namespace__=153, Class__=154, Traic__=155, Function__=156, Method__=157, 
+		Line__=158, File__=159, Dir__=160, Spaceship=161, Lgeneric=162, Rgeneric=163, 
+		DoubleArrow=164, Inc=165, Dec=166, IsIdentical=167, IsNoidentical=168, 
+		IsEqual=169, IsNotEq=170, IsSmallerOrEqual=171, IsGreaterOrEqual=172, 
+		PlusEqual=173, MinusEqual=174, MulEqual=175, Pow=176, PowEqual=177, DivEqual=178, 
+		Concaequal=179, ModEqual=180, ShiftLeftEqual=181, ShiftRightEqual=182, 
+		AndEqual=183, OrEqual=184, XorEqual=185, BooleanOr=186, BooleanAnd=187, 
+		NullCoalescing=188, NullCoalescingEqual=189, ShiftLeft=190, ShiftRight=191, 
+		DoubleColon=192, ObjectOperator=193, NamespaceSeparator=194, Ellipsis=195, 
+		Less=196, Greater=197, Ampersand=198, Pipe=199, Bang=200, Caret=201, Plus=202, 
+		Minus=203, Asterisk=204, Percent=205, Divide=206, Tilde=207, SuppressWarnings=208, 
+		Dollar=209, Dot=210, QuestionMark=211, OpenRoundBracket=212, CloseRoundBracket=213, 
+		OpenSquareBracket=214, CloseSquareBracket=215, OpenCurlyBracket=216, CloseCurlyBracket=217, 
+		Comma=218, Colon=219, SemiColon=220, Eq=221, Quote=222, BackQuote=223, 
+		VarName=224, Label=225, Octal=226, Decimal=227, Real=228, Hex=229, Binary=230, 
+		BackQuoteString=231, SingleQuoteString=232, DoubleQuote=233, StartNowDoc=234, 
+		StartHereDoc=235, ErrorPhp=236, CurlyDollar=237, UnicodeEscape=238, StringPart=239, 
+		Comment=240, PHPEndSingleLineComment=241, CommentEnd=242, HereDocText=243, 
+		XmlText2=244;
+	public static final int
+		RULE_htmlDocument = 0, RULE_inlineHtml = 1, RULE_htmlElement = 2, RULE_scriptText = 3, 
+		RULE_phpBlock = 4, RULE_importStatement = 5, RULE_topStatement = 6, RULE_useDeclaration = 7, 
+		RULE_useDeclarationContentList = 8, RULE_useDeclarationContent = 9, RULE_namespaceDeclaration = 10, 
+		RULE_namespaceStatement = 11, RULE_functionDeclaration = 12, RULE_classDeclaration = 13, 
+		RULE_classEntryType = 14, RULE_interfaceList = 15, RULE_typeParameterListInBrackets = 16, 
+		RULE_typeParameterList = 17, RULE_typeParameterWithDefaultsList = 18, 
+		RULE_typeParameterDecl = 19, RULE_typeParameterWithDefaultDecl = 20, RULE_genericDynamicArgs = 21, 
+		RULE_attributes = 22, RULE_attributeGroup = 23, RULE_attribute = 24, RULE_innerStatementList = 25, 
+		RULE_innerStatement = 26, RULE_statement = 27, RULE_emptyStatement_ = 28, 
+		RULE_blockStatement = 29, RULE_ifStatement = 30, RULE_elseIfStatement = 31, 
+		RULE_elseIfColonStatement = 32, RULE_elseStatement = 33, RULE_elseColonStatement = 34, 
+		RULE_whileStatement = 35, RULE_doWhileStatement = 36, RULE_forStatement = 37, 
+		RULE_forInit = 38, RULE_forUpdate = 39, RULE_switchStatement = 40, RULE_switchBlock = 41, 
+		RULE_breakStatement = 42, RULE_continueStatement = 43, RULE_returnStatement = 44, 
+		RULE_expressionStatement = 45, RULE_unsetStatement = 46, RULE_foreachStatement = 47, 
+		RULE_tryCatchFinally = 48, RULE_catchClause = 49, RULE_finallyStatement = 50, 
+		RULE_throwStatement = 51, RULE_gotoStatement = 52, RULE_declareStatement = 53, 
+		RULE_inlineHtmlStatement = 54, RULE_declareList = 55, RULE_directive = 56, 
+		RULE_formalParameterList = 57, RULE_formalParameter = 58, RULE_typeHint = 59, 
+		RULE_globalStatement = 60, RULE_globalVar = 61, RULE_echoStatement = 62, 
+		RULE_staticVariableStatement = 63, RULE_classStatement = 64, RULE_traitAdaptations = 65, 
+		RULE_traitAdaptationStatement = 66, RULE_traitPrecedence = 67, RULE_traitAlias = 68, 
+		RULE_traitMethodReference = 69, RULE_baseCtorCall = 70, RULE_returnTypeDecl = 71, 
+		RULE_methodBody = 72, RULE_propertyModifiers = 73, RULE_memberModifiers = 74, 
+		RULE_variableInitializer = 75, RULE_identifierInitializer = 76, RULE_globalConstantDeclaration = 77, 
+		RULE_enumDeclaration = 78, RULE_enumItem = 79, RULE_expressionList = 80, 
+		RULE_parentheses = 81, RULE_expression = 82, RULE_assignable = 83, RULE_arrayCreation = 84, 
+		RULE_arrayDestructuring = 85, RULE_indexedDestructItem = 86, RULE_keyedDestructItem = 87, 
+		RULE_lambdaFunctionExpr = 88, RULE_matchExpr = 89, RULE_matchItem = 90, 
+		RULE_newExpr = 91, RULE_assignmentOperator = 92, RULE_yieldExpression = 93, 
+		RULE_arrayItemList = 94, RULE_arrayItem = 95, RULE_lambdaFunctionUseVars = 96, 
+		RULE_lambdaFunctionUseVar = 97, RULE_qualifiedStaticTypeRef = 98, RULE_typeRef = 99, 
+		RULE_anonymousClass = 100, RULE_indirectTypeRef = 101, RULE_qualifiedNamespaceName = 102, 
+		RULE_namespaceNameList = 103, RULE_namespaceNameTail = 104, RULE_qualifiedNamespaceNameList = 105, 
+		RULE_arguments = 106, RULE_actualArgument = 107, RULE_argumentName = 108, 
+		RULE_constantInitializer = 109, RULE_constant = 110, RULE_literalConstant = 111, 
+		RULE_numericConstant = 112, RULE_classConstant = 113, RULE_stringConstant = 114, 
+		RULE_string = 115, RULE_interpolatedStringPart = 116, RULE_chainList = 117, 
+		RULE_chain = 118, RULE_chainOrigin = 119, RULE_memberAccess = 120, RULE_functionCall = 121, 
+		RULE_functionCallName = 122, RULE_actualArguments = 123, RULE_chainBase = 124, 
+		RULE_keyedFieldName = 125, RULE_keyedSimpleFieldName = 126, RULE_keyedVariable = 127, 
+		RULE_squareCurlyExpression = 128, RULE_assignmentList = 129, RULE_assignmentListElement = 130, 
+		RULE_modifier = 131, RULE_identifier = 132, RULE_memberModifier = 133, 
+		RULE_magicConstant = 134, RULE_magicMethod = 135, RULE_primitiveType = 136, 
+		RULE_castOperation = 137;
+	public static final String[] ruleNames = {
+		"htmlDocument", "inlineHtml", "htmlElement", "scriptText", "phpBlock", 
+		"importStatement", "topStatement", "useDeclaration", "useDeclarationContentList", 
+		"useDeclarationContent", "namespaceDeclaration", "namespaceStatement", 
+		"functionDeclaration", "classDeclaration", "classEntryType", "interfaceList", 
+		"typeParameterListInBrackets", "typeParameterList", "typeParameterWithDefaultsList", 
+		"typeParameterDecl", "typeParameterWithDefaultDecl", "genericDynamicArgs", 
+		"attributes", "attributeGroup", "attribute", "innerStatementList", "innerStatement", 
+		"statement", "emptyStatement_", "blockStatement", "ifStatement", "elseIfStatement", 
+		"elseIfColonStatement", "elseStatement", "elseColonStatement", "whileStatement", 
+		"doWhileStatement", "forStatement", "forInit", "forUpdate", "switchStatement", 
+		"switchBlock", "breakStatement", "continueStatement", "returnStatement", 
+		"expressionStatement", "unsetStatement", "foreachStatement", "tryCatchFinally", 
+		"catchClause", "finallyStatement", "throwStatement", "gotoStatement", 
+		"declareStatement", "inlineHtmlStatement", "declareList", "directive", 
+		"formalParameterList", "formalParameter", "typeHint", "globalStatement", 
+		"globalVar", "echoStatement", "staticVariableStatement", "classStatement", 
+		"traitAdaptations", "traitAdaptationStatement", "traitPrecedence", "traitAlias", 
+		"traitMethodReference", "baseCtorCall", "returnTypeDecl", "methodBody", 
+		"propertyModifiers", "memberModifiers", "variableInitializer", "identifierInitializer", 
+		"globalConstantDeclaration", "enumDeclaration", "enumItem", "expressionList", 
+		"parentheses", "expression", "assignable", "arrayCreation", "arrayDestructuring", 
+		"indexedDestructItem", "keyedDestructItem", "lambdaFunctionExpr", "matchExpr", 
+		"matchItem", "newExpr", "assignmentOperator", "yieldExpression", "arrayItemList", 
+		"arrayItem", "lambdaFunctionUseVars", "lambdaFunctionUseVar", "qualifiedStaticTypeRef", 
+		"typeRef", "anonymousClass", "indirectTypeRef", "qualifiedNamespaceName", 
+		"namespaceNameList", "namespaceNameTail", "qualifiedNamespaceNameList", 
+		"arguments", "actualArgument", "argumentName", "constantInitializer", 
+		"constant", "literalConstant", "numericConstant", "classConstant", "stringConstant", 
+		"string", "interpolatedStringPart", "chainList", "chain", "chainOrigin", 
+		"memberAccess", "functionCall", "functionCallName", "actualArguments", 
+		"chainBase", "keyedFieldName", "keyedSimpleFieldName", "keyedVariable", 
+		"squareCurlyExpression", "assignmentList", "assignmentListElement", "modifier", 
+		"identifier", "memberModifier", "magicConstant", "magicMethod", "primitiveType", 
+		"castOperation"
+	};
+
+	private static final String[] _LITERAL_NAMES = {
+		null, null, null, "'<?xml'", null, null, null, null, null, null, null, 
+		null, null, "'?>'", null, null, "'/>'", null, null, null, null, null, 
+		null, null, null, null, null, null, null, null, null, null, null, null, 
+		null, null, null, null, null, null, null, null, null, "'#['", "'abstract'", 
+		"'array'", "'as'", "'binary'", null, null, "'break'", "'callable'", "'case'", 
+		"'catch'", "'class'", "'clone'", "'const'", "'continue'", "'declare'", 
+		"'default'", "'do'", "'real'", "'double'", "'echo'", "'else'", "'elseif'", 
+		"'empty'", "'enum'", "'enddeclare'", "'endfor'", "'endforeach'", "'endif'", 
+		"'endswitch'", "'endwhile'", "'eval'", "'die'", "'extends'", "'final'", 
+		"'finally'", "'float'", "'for'", "'foreach'", "'function'", "'global'", 
+		"'goto'", "'if'", "'implements'", "'import'", "'include'", "'include_once'", 
+		"'instanceof'", "'insteadof'", "'int8'", "'int16'", "'int64'", null, "'interface'", 
+		"'isset'", "'list'", "'and'", "'or'", "'xor'", "'match'", "'namespace'", 
+		"'new'", "'null'", "'object'", "'parent'", "'partial'", "'print'", "'private'", 
+		"'protected'", "'public'", "'readonly'", "'require'", "'require_once'", 
+		"'resource'", "'return'", "'static'", "'string'", "'switch'", "'throw'", 
+		"'trait'", "'try'", "'clrtypeof'", null, "'unicode'", "'unset'", "'use'", 
+		"'var'", "'while'", "'yield'", "'from'", "'fn'", "'ticks'", "'encoding'", 
+		"'strict_types'", "'__get'", "'__set'", "'__call'", "'__callstatic'", 
+		"'__construct'", "'__destruct'", "'__wakeup'", "'__sleep'", "'__autoload'", 
+		"'__isset'", "'__unset'", "'__tostring'", "'__invoke'", "'__set_state'", 
+		"'__clone'", "'__debuginfo'", "'__namespace__'", "'__class__'", "'__trait__'", 
+		"'__function__'", "'__method__'", "'__line__'", "'__file__'", "'__dir__'", 
+		"'<=>'", "'<:'", "':>'", "'=>'", "'++'", "'--'", "'==='", "'!=='", "'=='", 
+		null, "'<='", "'>='", "'+='", "'-='", "'*='", "'**'", "'**='", "'/='", 
+		"'.='", "'%='", "'<<='", "'>>='", "'&='", "'|='", "'^='", "'||'", "'&&'", 
+		"'??'", "'??='", "'<<'", "'>>'", "'::'", "'->'", "'\\'", "'...'", null, 
+		null, "'&'", "'|'", "'!'", "'^'", "'+'", "'-'", "'*'", "'%'", null, "'~'", 
+		"'@'", null, "'.'", null, "'('", "')'", "'['", "']'", null, "'}'", "','", 
+		"':'", "';'", null, "'''", "'`'"
+	};
+	private static final String[] _SYMBOLIC_NAMES = {
+		null, "SeaWhitespace", "HtmlText", "XmlStart", "PHPStart", "HtmlScriptOpen", 
+		"HtmlStyleOpen", "HtmlComment", "HtmlDtd", "HtmlOpen", "Shebang", "Error", 
+		"XmlText", "XmlClose", "PHPStartInside", "HtmlClose", "HtmlSlashClose", 
+		"HtmlSlash", "HtmlEquals", "HtmlStartQuoteString", "HtmlStartDoubleQuoteString", 
+		"HtmlHex", "HtmlDecimal", "HtmlSpace", "HtmlName", "ErrorInside", "PHPStartInsideQuoteString", 
+		"HtmlEndQuoteString", "HtmlQuoteString", "ErrorHtmlQuote", "PHPStartDoubleQuoteString", 
+		"HtmlEndDoubleQuoteString", "HtmlDoubleQuoteString", "ErrorHtmlDoubleQuote", 
+		"ScriptText", "HtmlScriptClose", "PHPStartInsideScript", "StyleBody", 
+		"PHPEnd", "Whitespace", "MultiLineComment", "SingleLineComment", "ShellStyleComment", 
+		"AttributeStart", "Abstract", "Array", "As", "BinaryCast", "BoolType", 
+		"BooleanConstant", "Break", "Callable", "Case", "Catch", "Class", "Clone", 
+		"Const", "Continue", "Declare", "Default", "Do", "DoubleCast", "DoubleType", 
+		"Echo", "Else", "ElseIf", "Empty", "Enum_", "EndDeclare", "EndFor", "EndForeach", 
+		"EndIf", "EndSwitch", "EndWhile", "Eval", "Exit", "Extends", "Final", 
+		"Finally", "FloatCast", "For", "Foreach", "Function_", "Global", "Goto", 
+		"If", "Implements", "Import", "Include", "IncludeOnce", "InstanceOf", 
+		"InsteadOf", "Int8Cast", "Int16Cast", "Int64Type", "IntType", "Interface", 
+		"IsSet", "List", "LogicalAnd", "LogicalOr", "LogicalXor", "Match_", "Namespace", 
+		"New", "Null", "ObjectType", "Parent_", "Partial", "Print", "Private", 
+		"Protected", "Public", "Readonly", "Require", "RequireOnce", "Resource", 
+		"Return", "Static", "StringType", "Switch", "Throw", "Trait", "Try", "Typeof", 
+		"UintCast", "UnicodeCast", "Unset", "Use", "Var", "While", "Yield", "From", 
+		"LambdaFn", "Ticks", "Encoding", "StrictTypes", "Get", "Set", "Call", 
+		"CallStatic", "Constructor", "Destruct", "Wakeup", "Sleep", "Autoload", 
+		"IsSet__", "Unset__", "ToString__", "Invoke", "SetState", "Clone__", "DebugInfo", 
+		"Namespace__", "Class__", "Traic__", "Function__", "Method__", "Line__", 
+		"File__", "Dir__", "Spaceship", "Lgeneric", "Rgeneric", "DoubleArrow", 
+		"Inc", "Dec", "IsIdentical", "IsNoidentical", "IsEqual", "IsNotEq", "IsSmallerOrEqual", 
+		"IsGreaterOrEqual", "PlusEqual", "MinusEqual", "MulEqual", "Pow", "PowEqual", 
+		"DivEqual", "Concaequal", "ModEqual", "ShiftLeftEqual", "ShiftRightEqual", 
+		"AndEqual", "OrEqual", "XorEqual", "BooleanOr", "BooleanAnd", "NullCoalescing", 
+		"NullCoalescingEqual", "ShiftLeft", "ShiftRight", "DoubleColon", "ObjectOperator", 
+		"NamespaceSeparator", "Ellipsis", "Less", "Greater", "Ampersand", "Pipe", 
+		"Bang", "Caret", "Plus", "Minus", "Asterisk", "Percent", "Divide", "Tilde", 
+		"SuppressWarnings", "Dollar", "Dot", "QuestionMark", "OpenRoundBracket", 
+		"CloseRoundBracket", "OpenSquareBracket", "CloseSquareBracket", "OpenCurlyBracket", 
+		"CloseCurlyBracket", "Comma", "Colon", "SemiColon", "Eq", "Quote", "BackQuote", 
+		"VarName", "Label", "Octal", "Decimal", "Real", "Hex", "Binary", "BackQuoteString", 
+		"SingleQuoteString", "DoubleQuote", "StartNowDoc", "StartHereDoc", "ErrorPhp", 
+		"CurlyDollar", "UnicodeEscape", "StringPart", "Comment", "PHPEndSingleLineComment", 
+		"CommentEnd", "HereDocText", "XmlText2"
+	};
+	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
+
+	/**
+	 * @deprecated Use {@link #VOCABULARY} instead.
+	 */
+	@Deprecated
+	public static final String[] tokenNames;
+	static {
+		tokenNames = new String[_SYMBOLIC_NAMES.length];
+		for (int i = 0; i < tokenNames.length; i++) {
+			tokenNames[i] = VOCABULARY.getLiteralName(i);
+			if (tokenNames[i] == null) {
+				tokenNames[i] = VOCABULARY.getSymbolicName(i);
+			}
+
+			if (tokenNames[i] == null) {
+				tokenNames[i] = "<INVALID>";
+			}
+		}
+	}
+
+	@Override
+	@Deprecated
+	public String[] getTokenNames() {
+		return tokenNames;
+	}
+
+	@Override
+
+	public Vocabulary getVocabulary() {
+		return VOCABULARY;
+	}
+
+	@Override
+	public String getGrammarFileName() { return "PhpParser.g4"; }
+
+	@Override
+	public String[] getRuleNames() { return ruleNames; }
+
+	@Override
+	public String getSerializedATN() { return _serializedATN; }
+
+	@Override
+	public ATN getATN() { return _ATN; }
+
+	public PhpParser(TokenStream input) {
+		super(input);
+		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
+	}
+	public static class HtmlDocumentContext extends ParserRuleContext {
+		public TerminalNode EOF() { return getToken(PhpParser.EOF, 0); }
+		public TerminalNode Shebang() { return getToken(PhpParser.Shebang, 0); }
+		public List<InlineHtmlContext> inlineHtml() {
+			return getRuleContexts(InlineHtmlContext.class);
+		}
+		public InlineHtmlContext inlineHtml(int i) {
+			return getRuleContext(InlineHtmlContext.class,i);
+		}
+		public List<PhpBlockContext> phpBlock() {
+			return getRuleContexts(PhpBlockContext.class);
+		}
+		public PhpBlockContext phpBlock(int i) {
+			return getRuleContext(PhpBlockContext.class,i);
+		}
+		public HtmlDocumentContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_htmlDocument; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterHtmlDocument(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitHtmlDocument(this);
+		}
+	}
+
+	public final HtmlDocumentContext htmlDocument() throws RecognitionException {
+		HtmlDocumentContext _localctx = new HtmlDocumentContext(_ctx, getState());
+		enterRule(_localctx, 0, RULE_htmlDocument);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(277);
+			_la = _input.LA(1);
+			if (_la==Shebang) {
+				{
+				setState(276);
+				match(Shebang);
+				}
+			}
+
+			setState(283);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << HtmlText) | (1L << XmlStart) | (1L << HtmlScriptOpen) | (1L << HtmlStyleOpen) | (1L << HtmlDtd) | (1L << HtmlOpen) | (1L << HtmlClose) | (1L << HtmlSlashClose) | (1L << HtmlSlash) | (1L << HtmlEquals) | (1L << HtmlStartQuoteString) | (1L << HtmlStartDoubleQuoteString) | (1L << HtmlHex) | (1L << HtmlDecimal) | (1L << HtmlName) | (1L << HtmlEndQuoteString) | (1L << HtmlQuoteString) | (1L << HtmlEndDoubleQuoteString) | (1L << HtmlDoubleQuoteString) | (1L << ScriptText) | (1L << HtmlScriptClose) | (1L << StyleBody) | (1L << AttributeStart) | (1L << Abstract) | (1L << Array) | (1L << As) | (1L << BinaryCast) | (1L << BoolType) | (1L << BooleanConstant) | (1L << Break) | (1L << Callable) | (1L << Case) | (1L << Catch) | (1L << Class) | (1L << Clone) | (1L << Const) | (1L << Continue) | (1L << Declare) | (1L << Default) | (1L << Do) | (1L << DoubleCast) | (1L << DoubleType) | (1L << Echo))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Else - 64)) | (1L << (ElseIf - 64)) | (1L << (Empty - 64)) | (1L << (Enum_ - 64)) | (1L << (EndDeclare - 64)) | (1L << (EndFor - 64)) | (1L << (EndForeach - 64)) | (1L << (EndIf - 64)) | (1L << (EndSwitch - 64)) | (1L << (EndWhile - 64)) | (1L << (Eval - 64)) | (1L << (Exit - 64)) | (1L << (Extends - 64)) | (1L << (Final - 64)) | (1L << (Finally - 64)) | (1L << (FloatCast - 64)) | (1L << (For - 64)) | (1L << (Foreach - 64)) | (1L << (Function_ - 64)) | (1L << (Global - 64)) | (1L << (Goto - 64)) | (1L << (If - 64)) | (1L << (Implements - 64)) | (1L << (Import - 64)) | (1L << (Include - 64)) | (1L << (IncludeOnce - 64)) | (1L << (InstanceOf - 64)) | (1L << (InsteadOf - 64)) | (1L << (Int8Cast - 64)) | (1L << (Int16Cast - 64)) | (1L << (Int64Type - 64)) | (1L << (IntType - 64)) | (1L << (Interface - 64)) | (1L << (IsSet - 64)) | (1L << (List - 64)) | (1L << (LogicalAnd - 64)) | (1L << (LogicalOr - 64)) | (1L << (LogicalXor - 64)) | (1L << (Match_ - 64)) | (1L << (Namespace - 64)) | (1L << (New - 64)) | (1L << (Null - 64)) | (1L << (ObjectType - 64)) | (1L << (Parent_ - 64)) | (1L << (Partial - 64)) | (1L << (Print - 64)) | (1L << (Private - 64)) | (1L << (Protected - 64)) | (1L << (Public - 64)) | (1L << (Readonly - 64)) | (1L << (Require - 64)) | (1L << (RequireOnce - 64)) | (1L << (Resource - 64)) | (1L << (Return - 64)) | (1L << (Static - 64)) | (1L << (StringType - 64)) | (1L << (Switch - 64)) | (1L << (Throw - 64)) | (1L << (Trait - 64)) | (1L << (Try - 64)) | (1L << (Typeof - 64)) | (1L << (UintCast - 64)) | (1L << (UnicodeCast - 64)) | (1L << (Unset - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Use - 128)) | (1L << (Var - 128)) | (1L << (While - 128)) | (1L << (Yield - 128)) | (1L << (From - 128)) | (1L << (LambdaFn - 128)) | (1L << (Ticks - 128)) | (1L << (Encoding - 128)) | (1L << (StrictTypes - 128)) | (1L << (Get - 128)) | (1L << (Set - 128)) | (1L << (Call - 128)) | (1L << (CallStatic - 128)) | (1L << (Constructor - 128)) | (1L << (Destruct - 128)) | (1L << (Wakeup - 128)) | (1L << (Sleep - 128)) | (1L << (Autoload - 128)) | (1L << (IsSet__ - 128)) | (1L << (Unset__ - 128)) | (1L << (ToString__ - 128)) | (1L << (Invoke - 128)) | (1L << (SetState - 128)) | (1L << (Clone__ - 128)) | (1L << (DebugInfo - 128)) | (1L << (Namespace__ - 128)) | (1L << (Class__ - 128)) | (1L << (Traic__ - 128)) | (1L << (Function__ - 128)) | (1L << (Method__ - 128)) | (1L << (Line__ - 128)) | (1L << (File__ - 128)) | (1L << (Dir__ - 128)) | (1L << (Inc - 128)) | (1L << (Dec - 128)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (OpenCurlyBracket - 194)) | (1L << (SemiColon - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) {
+				{
+				setState(281);
+				switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
+				case 1:
+					{
+					setState(279);
+					inlineHtml();
+					}
+					break;
+				case 2:
+					{
+					setState(280);
+					phpBlock();
+					}
+					break;
+				}
+				}
+				setState(285);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(286);
+			match(EOF);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InlineHtmlContext extends ParserRuleContext {
+		public List<HtmlElementContext> htmlElement() {
+			return getRuleContexts(HtmlElementContext.class);
+		}
+		public HtmlElementContext htmlElement(int i) {
+			return getRuleContext(HtmlElementContext.class,i);
+		}
+		public ScriptTextContext scriptText() {
+			return getRuleContext(ScriptTextContext.class,0);
+		}
+		public InlineHtmlContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_inlineHtml; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterInlineHtml(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitInlineHtml(this);
+		}
+	}
+
+	public final InlineHtmlContext inlineHtml() throws RecognitionException {
+		InlineHtmlContext _localctx = new InlineHtmlContext(_ctx, getState());
+		enterRule(_localctx, 2, RULE_inlineHtml);
+		try {
+			int _alt;
+			setState(294);
+			switch (_input.LA(1)) {
+			case HtmlText:
+			case XmlStart:
+			case HtmlScriptOpen:
+			case HtmlStyleOpen:
+			case HtmlDtd:
+			case HtmlOpen:
+			case HtmlClose:
+			case HtmlSlashClose:
+			case HtmlSlash:
+			case HtmlEquals:
+			case HtmlStartQuoteString:
+			case HtmlStartDoubleQuoteString:
+			case HtmlHex:
+			case HtmlDecimal:
+			case HtmlName:
+			case HtmlEndQuoteString:
+			case HtmlQuoteString:
+			case HtmlEndDoubleQuoteString:
+			case HtmlDoubleQuoteString:
+			case HtmlScriptClose:
+			case StyleBody:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(289); 
+				_errHandler.sync(this);
+				_alt = 1;
+				do {
+					switch (_alt) {
+					case 1:
+						{
+						{
+						setState(288);
+						htmlElement();
+						}
+						}
+						break;
+					default:
+						throw new NoViableAltException(this);
+					}
+					setState(291); 
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
+				} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+				}
+				break;
+			case ScriptText:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(293);
+				scriptText();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class HtmlElementContext extends ParserRuleContext {
+		public TerminalNode HtmlDtd() { return getToken(PhpParser.HtmlDtd, 0); }
+		public TerminalNode HtmlClose() { return getToken(PhpParser.HtmlClose, 0); }
+		public TerminalNode HtmlStyleOpen() { return getToken(PhpParser.HtmlStyleOpen, 0); }
+		public TerminalNode HtmlOpen() { return getToken(PhpParser.HtmlOpen, 0); }
+		public TerminalNode HtmlName() { return getToken(PhpParser.HtmlName, 0); }
+		public TerminalNode HtmlSlashClose() { return getToken(PhpParser.HtmlSlashClose, 0); }
+		public TerminalNode HtmlSlash() { return getToken(PhpParser.HtmlSlash, 0); }
+		public TerminalNode HtmlText() { return getToken(PhpParser.HtmlText, 0); }
+		public TerminalNode HtmlEquals() { return getToken(PhpParser.HtmlEquals, 0); }
+		public TerminalNode HtmlStartQuoteString() { return getToken(PhpParser.HtmlStartQuoteString, 0); }
+		public TerminalNode HtmlEndQuoteString() { return getToken(PhpParser.HtmlEndQuoteString, 0); }
+		public TerminalNode HtmlStartDoubleQuoteString() { return getToken(PhpParser.HtmlStartDoubleQuoteString, 0); }
+		public TerminalNode HtmlEndDoubleQuoteString() { return getToken(PhpParser.HtmlEndDoubleQuoteString, 0); }
+		public TerminalNode HtmlHex() { return getToken(PhpParser.HtmlHex, 0); }
+		public TerminalNode HtmlDecimal() { return getToken(PhpParser.HtmlDecimal, 0); }
+		public TerminalNode HtmlQuoteString() { return getToken(PhpParser.HtmlQuoteString, 0); }
+		public TerminalNode HtmlDoubleQuoteString() { return getToken(PhpParser.HtmlDoubleQuoteString, 0); }
+		public TerminalNode StyleBody() { return getToken(PhpParser.StyleBody, 0); }
+		public TerminalNode HtmlScriptOpen() { return getToken(PhpParser.HtmlScriptOpen, 0); }
+		public TerminalNode HtmlScriptClose() { return getToken(PhpParser.HtmlScriptClose, 0); }
+		public TerminalNode XmlStart() { return getToken(PhpParser.XmlStart, 0); }
+		public TerminalNode XmlClose() { return getToken(PhpParser.XmlClose, 0); }
+		public List<TerminalNode> XmlText() { return getTokens(PhpParser.XmlText); }
+		public TerminalNode XmlText(int i) {
+			return getToken(PhpParser.XmlText, i);
+		}
+		public HtmlElementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_htmlElement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterHtmlElement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitHtmlElement(this);
+		}
+	}
+
+	public final HtmlElementContext htmlElement() throws RecognitionException {
+		HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState());
+		enterRule(_localctx, 4, RULE_htmlElement);
+		int _la;
+		try {
+			setState(324);
+			switch (_input.LA(1)) {
+			case HtmlDtd:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(296);
+				match(HtmlDtd);
+				}
+				break;
+			case HtmlClose:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(297);
+				match(HtmlClose);
+				}
+				break;
+			case HtmlStyleOpen:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(298);
+				match(HtmlStyleOpen);
+				}
+				break;
+			case HtmlOpen:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(299);
+				match(HtmlOpen);
+				}
+				break;
+			case HtmlName:
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(300);
+				match(HtmlName);
+				}
+				break;
+			case HtmlSlashClose:
+				enterOuterAlt(_localctx, 6);
+				{
+				setState(301);
+				match(HtmlSlashClose);
+				}
+				break;
+			case HtmlSlash:
+				enterOuterAlt(_localctx, 7);
+				{
+				setState(302);
+				match(HtmlSlash);
+				}
+				break;
+			case HtmlText:
+				enterOuterAlt(_localctx, 8);
+				{
+				setState(303);
+				match(HtmlText);
+				}
+				break;
+			case HtmlEquals:
+				enterOuterAlt(_localctx, 9);
+				{
+				setState(304);
+				match(HtmlEquals);
+				}
+				break;
+			case HtmlStartQuoteString:
+				enterOuterAlt(_localctx, 10);
+				{
+				setState(305);
+				match(HtmlStartQuoteString);
+				}
+				break;
+			case HtmlEndQuoteString:
+				enterOuterAlt(_localctx, 11);
+				{
+				setState(306);
+				match(HtmlEndQuoteString);
+				}
+				break;
+			case HtmlStartDoubleQuoteString:
+				enterOuterAlt(_localctx, 12);
+				{
+				setState(307);
+				match(HtmlStartDoubleQuoteString);
+				}
+				break;
+			case HtmlEndDoubleQuoteString:
+				enterOuterAlt(_localctx, 13);
+				{
+				setState(308);
+				match(HtmlEndDoubleQuoteString);
+				}
+				break;
+			case HtmlHex:
+				enterOuterAlt(_localctx, 14);
+				{
+				setState(309);
+				match(HtmlHex);
+				}
+				break;
+			case HtmlDecimal:
+				enterOuterAlt(_localctx, 15);
+				{
+				setState(310);
+				match(HtmlDecimal);
+				}
+				break;
+			case HtmlQuoteString:
+				enterOuterAlt(_localctx, 16);
+				{
+				setState(311);
+				match(HtmlQuoteString);
+				}
+				break;
+			case HtmlDoubleQuoteString:
+				enterOuterAlt(_localctx, 17);
+				{
+				setState(312);
+				match(HtmlDoubleQuoteString);
+				}
+				break;
+			case StyleBody:
+				enterOuterAlt(_localctx, 18);
+				{
+				setState(313);
+				match(StyleBody);
+				}
+				break;
+			case HtmlScriptOpen:
+				enterOuterAlt(_localctx, 19);
+				{
+				setState(314);
+				match(HtmlScriptOpen);
+				}
+				break;
+			case HtmlScriptClose:
+				enterOuterAlt(_localctx, 20);
+				{
+				setState(315);
+				match(HtmlScriptClose);
+				}
+				break;
+			case XmlStart:
+				enterOuterAlt(_localctx, 21);
+				{
+				setState(316);
+				match(XmlStart);
+				setState(320);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==XmlText) {
+					{
+					{
+					setState(317);
+					match(XmlText);
+					}
+					}
+					setState(322);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(323);
+				match(XmlClose);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ScriptTextContext extends ParserRuleContext {
+		public List<TerminalNode> ScriptText() { return getTokens(PhpParser.ScriptText); }
+		public TerminalNode ScriptText(int i) {
+			return getToken(PhpParser.ScriptText, i);
+		}
+		public ScriptTextContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_scriptText; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterScriptText(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitScriptText(this);
+		}
+	}
+
+	public final ScriptTextContext scriptText() throws RecognitionException {
+		ScriptTextContext _localctx = new ScriptTextContext(_ctx, getState());
+		enterRule(_localctx, 6, RULE_scriptText);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(327); 
+			_errHandler.sync(this);
+			_alt = 1;
+			do {
+				switch (_alt) {
+				case 1:
+					{
+					{
+					setState(326);
+					match(ScriptText);
+					}
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				setState(329); 
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
+			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class PhpBlockContext extends ParserRuleContext {
+		public List<ImportStatementContext> importStatement() {
+			return getRuleContexts(ImportStatementContext.class);
+		}
+		public ImportStatementContext importStatement(int i) {
+			return getRuleContext(ImportStatementContext.class,i);
+		}
+		public List<TopStatementContext> topStatement() {
+			return getRuleContexts(TopStatementContext.class);
+		}
+		public TopStatementContext topStatement(int i) {
+			return getRuleContext(TopStatementContext.class,i);
+		}
+		public PhpBlockContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_phpBlock; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterPhpBlock(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitPhpBlock(this);
+		}
+	}
+
+	public final PhpBlockContext phpBlock() throws RecognitionException {
+		PhpBlockContext _localctx = new PhpBlockContext(_ctx, getState());
+		enterRule(_localctx, 8, RULE_phpBlock);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(334);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(331);
+					importStatement();
+					}
+					} 
+				}
+				setState(336);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
+			}
+			setState(338); 
+			_errHandler.sync(this);
+			_alt = 1;
+			do {
+				switch (_alt) {
+				case 1:
+					{
+					{
+					setState(337);
+					topStatement();
+					}
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				setState(340); 
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,9,_ctx);
+			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ImportStatementContext extends ParserRuleContext {
+		public TerminalNode Import() { return getToken(PhpParser.Import, 0); }
+		public TerminalNode Namespace() { return getToken(PhpParser.Namespace, 0); }
+		public NamespaceNameListContext namespaceNameList() {
+			return getRuleContext(NamespaceNameListContext.class,0);
+		}
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public ImportStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_importStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterImportStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitImportStatement(this);
+		}
+	}
+
+	public final ImportStatementContext importStatement() throws RecognitionException {
+		ImportStatementContext _localctx = new ImportStatementContext(_ctx, getState());
+		enterRule(_localctx, 10, RULE_importStatement);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(342);
+			match(Import);
+			setState(343);
+			match(Namespace);
+			setState(344);
+			namespaceNameList();
+			setState(345);
+			match(SemiColon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TopStatementContext extends ParserRuleContext {
+		public StatementContext statement() {
+			return getRuleContext(StatementContext.class,0);
+		}
+		public UseDeclarationContext useDeclaration() {
+			return getRuleContext(UseDeclarationContext.class,0);
+		}
+		public NamespaceDeclarationContext namespaceDeclaration() {
+			return getRuleContext(NamespaceDeclarationContext.class,0);
+		}
+		public FunctionDeclarationContext functionDeclaration() {
+			return getRuleContext(FunctionDeclarationContext.class,0);
+		}
+		public ClassDeclarationContext classDeclaration() {
+			return getRuleContext(ClassDeclarationContext.class,0);
+		}
+		public GlobalConstantDeclarationContext globalConstantDeclaration() {
+			return getRuleContext(GlobalConstantDeclarationContext.class,0);
+		}
+		public EnumDeclarationContext enumDeclaration() {
+			return getRuleContext(EnumDeclarationContext.class,0);
+		}
+		public TopStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_topStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTopStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTopStatement(this);
+		}
+	}
+
+	public final TopStatementContext topStatement() throws RecognitionException {
+		TopStatementContext _localctx = new TopStatementContext(_ctx, getState());
+		enterRule(_localctx, 12, RULE_topStatement);
+		try {
+			setState(354);
+			switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(347);
+				statement();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(348);
+				useDeclaration();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(349);
+				namespaceDeclaration();
+				}
+				break;
+			case 4:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(350);
+				functionDeclaration();
+				}
+				break;
+			case 5:
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(351);
+				classDeclaration();
+				}
+				break;
+			case 6:
+				enterOuterAlt(_localctx, 6);
+				{
+				setState(352);
+				globalConstantDeclaration();
+				}
+				break;
+			case 7:
+				enterOuterAlt(_localctx, 7);
+				{
+				setState(353);
+				enumDeclaration();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class UseDeclarationContext extends ParserRuleContext {
+		public TerminalNode Use() { return getToken(PhpParser.Use, 0); }
+		public UseDeclarationContentListContext useDeclarationContentList() {
+			return getRuleContext(UseDeclarationContentListContext.class,0);
+		}
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public TerminalNode Function_() { return getToken(PhpParser.Function_, 0); }
+		public TerminalNode Const() { return getToken(PhpParser.Const, 0); }
+		public UseDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_useDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterUseDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitUseDeclaration(this);
+		}
+	}
+
+	public final UseDeclarationContext useDeclaration() throws RecognitionException {
+		UseDeclarationContext _localctx = new UseDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 14, RULE_useDeclaration);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(356);
+			match(Use);
+			setState(358);
+			switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
+			case 1:
+				{
+				setState(357);
+				_la = _input.LA(1);
+				if ( !(_la==Const || _la==Function_) ) {
+				_errHandler.recoverInline(this);
+				} else {
+					consume();
+				}
+				}
+				break;
+			}
+			setState(360);
+			useDeclarationContentList();
+			setState(361);
+			match(SemiColon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class UseDeclarationContentListContext extends ParserRuleContext {
+		public List<UseDeclarationContentContext> useDeclarationContent() {
+			return getRuleContexts(UseDeclarationContentContext.class);
+		}
+		public UseDeclarationContentContext useDeclarationContent(int i) {
+			return getRuleContext(UseDeclarationContentContext.class,i);
+		}
+		public UseDeclarationContentListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_useDeclarationContentList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterUseDeclarationContentList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitUseDeclarationContentList(this);
+		}
+	}
+
+	public final UseDeclarationContentListContext useDeclarationContentList() throws RecognitionException {
+		UseDeclarationContentListContext _localctx = new UseDeclarationContentListContext(_ctx, getState());
+		enterRule(_localctx, 16, RULE_useDeclarationContentList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(364);
+			_la = _input.LA(1);
+			if (_la==NamespaceSeparator) {
+				{
+				setState(363);
+				match(NamespaceSeparator);
+				}
+			}
+
+			setState(366);
+			useDeclarationContent();
+			setState(374);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==Comma) {
+				{
+				{
+				setState(367);
+				match(Comma);
+				setState(369);
+				_la = _input.LA(1);
+				if (_la==NamespaceSeparator) {
+					{
+					setState(368);
+					match(NamespaceSeparator);
+					}
+				}
+
+				setState(371);
+				useDeclarationContent();
+				}
+				}
+				setState(376);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class UseDeclarationContentContext extends ParserRuleContext {
+		public NamespaceNameListContext namespaceNameList() {
+			return getRuleContext(NamespaceNameListContext.class,0);
+		}
+		public UseDeclarationContentContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_useDeclarationContent; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterUseDeclarationContent(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitUseDeclarationContent(this);
+		}
+	}
+
+	public final UseDeclarationContentContext useDeclarationContent() throws RecognitionException {
+		UseDeclarationContentContext _localctx = new UseDeclarationContentContext(_ctx, getState());
+		enterRule(_localctx, 18, RULE_useDeclarationContent);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(377);
+			namespaceNameList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class NamespaceDeclarationContext extends ParserRuleContext {
+		public TerminalNode Namespace() { return getToken(PhpParser.Namespace, 0); }
+		public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); }
+		public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); }
+		public NamespaceNameListContext namespaceNameList() {
+			return getRuleContext(NamespaceNameListContext.class,0);
+		}
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public List<NamespaceStatementContext> namespaceStatement() {
+			return getRuleContexts(NamespaceStatementContext.class);
+		}
+		public NamespaceStatementContext namespaceStatement(int i) {
+			return getRuleContext(NamespaceStatementContext.class,i);
+		}
+		public NamespaceDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_namespaceDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterNamespaceDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitNamespaceDeclaration(this);
+		}
+	}
+
+	public final NamespaceDeclarationContext namespaceDeclaration() throws RecognitionException {
+		NamespaceDeclarationContext _localctx = new NamespaceDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 20, RULE_namespaceDeclaration);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(379);
+			match(Namespace);
+			setState(394);
+			switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
+			case 1:
+				{
+				setState(381);
+				_la = _input.LA(1);
+				if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)))) != 0) || _la==Label) {
+					{
+					setState(380);
+					namespaceNameList();
+					}
+				}
+
+				setState(383);
+				match(OpenCurlyBracket);
+				setState(387);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << HtmlText) | (1L << XmlStart) | (1L << HtmlScriptOpen) | (1L << HtmlStyleOpen) | (1L << HtmlDtd) | (1L << HtmlOpen) | (1L << HtmlClose) | (1L << HtmlSlashClose) | (1L << HtmlSlash) | (1L << HtmlEquals) | (1L << HtmlStartQuoteString) | (1L << HtmlStartDoubleQuoteString) | (1L << HtmlHex) | (1L << HtmlDecimal) | (1L << HtmlName) | (1L << HtmlEndQuoteString) | (1L << HtmlQuoteString) | (1L << HtmlEndDoubleQuoteString) | (1L << HtmlDoubleQuoteString) | (1L << ScriptText) | (1L << HtmlScriptClose) | (1L << StyleBody) | (1L << AttributeStart) | (1L << Abstract) | (1L << Array) | (1L << As) | (1L << BinaryCast) | (1L << BoolType) | (1L << BooleanConstant) | (1L << Break) | (1L << Callable) | (1L << Case) | (1L << Catch) | (1L << Class) | (1L << Clone) | (1L << Const) | (1L << Continue) | (1L << Declare) | (1L << Default) | (1L << Do) | (1L << DoubleCast) | (1L << DoubleType) | (1L << Echo))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Else - 64)) | (1L << (ElseIf - 64)) | (1L << (Empty - 64)) | (1L << (Enum_ - 64)) | (1L << (EndDeclare - 64)) | (1L << (EndFor - 64)) | (1L << (EndForeach - 64)) | (1L << (EndIf - 64)) | (1L << (EndSwitch - 64)) | (1L << (EndWhile - 64)) | (1L << (Eval - 64)) | (1L << (Exit - 64)) | (1L << (Extends - 64)) | (1L << (Final - 64)) | (1L << (Finally - 64)) | (1L << (FloatCast - 64)) | (1L << (For - 64)) | (1L << (Foreach - 64)) | (1L << (Function_ - 64)) | (1L << (Global - 64)) | (1L << (Goto - 64)) | (1L << (If - 64)) | (1L << (Implements - 64)) | (1L << (Import - 64)) | (1L << (Include - 64)) | (1L << (IncludeOnce - 64)) | (1L << (InstanceOf - 64)) | (1L << (InsteadOf - 64)) | (1L << (Int8Cast - 64)) | (1L << (Int16Cast - 64)) | (1L << (Int64Type - 64)) | (1L << (IntType - 64)) | (1L << (Interface - 64)) | (1L << (IsSet - 64)) | (1L << (List - 64)) | (1L << (LogicalAnd - 64)) | (1L << (LogicalOr - 64)) | (1L << (LogicalXor - 64)) | (1L << (Match_ - 64)) | (1L << (Namespace - 64)) | (1L << (New - 64)) | (1L << (Null - 64)) | (1L << (ObjectType - 64)) | (1L << (Parent_ - 64)) | (1L << (Partial - 64)) | (1L << (Print - 64)) | (1L << (Private - 64)) | (1L << (Protected - 64)) | (1L << (Public - 64)) | (1L << (Readonly - 64)) | (1L << (Require - 64)) | (1L << (RequireOnce - 64)) | (1L << (Resource - 64)) | (1L << (Return - 64)) | (1L << (Static - 64)) | (1L << (StringType - 64)) | (1L << (Switch - 64)) | (1L << (Throw - 64)) | (1L << (Trait - 64)) | (1L << (Try - 64)) | (1L << (Typeof - 64)) | (1L << (UintCast - 64)) | (1L << (UnicodeCast - 64)) | (1L << (Unset - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Use - 128)) | (1L << (Var - 128)) | (1L << (While - 128)) | (1L << (Yield - 128)) | (1L << (From - 128)) | (1L << (LambdaFn - 128)) | (1L << (Ticks - 128)) | (1L << (Encoding - 128)) | (1L << (StrictTypes - 128)) | (1L << (Get - 128)) | (1L << (Set - 128)) | (1L << (Call - 128)) | (1L << (CallStatic - 128)) | (1L << (Constructor - 128)) | (1L << (Destruct - 128)) | (1L << (Wakeup - 128)) | (1L << (Sleep - 128)) | (1L << (Autoload - 128)) | (1L << (IsSet__ - 128)) | (1L << (Unset__ - 128)) | (1L << (ToString__ - 128)) | (1L << (Invoke - 128)) | (1L << (SetState - 128)) | (1L << (Clone__ - 128)) | (1L << (DebugInfo - 128)) | (1L << (Namespace__ - 128)) | (1L << (Class__ - 128)) | (1L << (Traic__ - 128)) | (1L << (Function__ - 128)) | (1L << (Method__ - 128)) | (1L << (Line__ - 128)) | (1L << (File__ - 128)) | (1L << (Dir__ - 128)) | (1L << (Inc - 128)) | (1L << (Dec - 128)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (OpenCurlyBracket - 194)) | (1L << (SemiColon - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) {
+					{
+					{
+					setState(384);
+					namespaceStatement();
+					}
+					}
+					setState(389);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(390);
+				match(CloseCurlyBracket);
+				}
+				break;
+			case 2:
+				{
+				setState(391);
+				namespaceNameList();
+				setState(392);
+				match(SemiColon);
+				}
+				break;
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class NamespaceStatementContext extends ParserRuleContext {
+		public StatementContext statement() {
+			return getRuleContext(StatementContext.class,0);
+		}
+		public UseDeclarationContext useDeclaration() {
+			return getRuleContext(UseDeclarationContext.class,0);
+		}
+		public FunctionDeclarationContext functionDeclaration() {
+			return getRuleContext(FunctionDeclarationContext.class,0);
+		}
+		public ClassDeclarationContext classDeclaration() {
+			return getRuleContext(ClassDeclarationContext.class,0);
+		}
+		public GlobalConstantDeclarationContext globalConstantDeclaration() {
+			return getRuleContext(GlobalConstantDeclarationContext.class,0);
+		}
+		public NamespaceStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_namespaceStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterNamespaceStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitNamespaceStatement(this);
+		}
+	}
+
+	public final NamespaceStatementContext namespaceStatement() throws RecognitionException {
+		NamespaceStatementContext _localctx = new NamespaceStatementContext(_ctx, getState());
+		enterRule(_localctx, 22, RULE_namespaceStatement);
+		try {
+			setState(401);
+			switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(396);
+				statement();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(397);
+				useDeclaration();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(398);
+				functionDeclaration();
+				}
+				break;
+			case 4:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(399);
+				classDeclaration();
+				}
+				break;
+			case 5:
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(400);
+				globalConstantDeclaration();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class FunctionDeclarationContext extends ParserRuleContext {
+		public TerminalNode Function_() { return getToken(PhpParser.Function_, 0); }
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public FormalParameterListContext formalParameterList() {
+			return getRuleContext(FormalParameterListContext.class,0);
+		}
+		public BlockStatementContext blockStatement() {
+			return getRuleContext(BlockStatementContext.class,0);
+		}
+		public AttributesContext attributes() {
+			return getRuleContext(AttributesContext.class,0);
+		}
+		public TypeParameterListInBracketsContext typeParameterListInBrackets() {
+			return getRuleContext(TypeParameterListInBracketsContext.class,0);
+		}
+		public TypeHintContext typeHint() {
+			return getRuleContext(TypeHintContext.class,0);
+		}
+		public TerminalNode QuestionMark() { return getToken(PhpParser.QuestionMark, 0); }
+		public FunctionDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_functionDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterFunctionDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitFunctionDeclaration(this);
+		}
+	}
+
+	public final FunctionDeclarationContext functionDeclaration() throws RecognitionException {
+		FunctionDeclarationContext _localctx = new FunctionDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 24, RULE_functionDeclaration);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(404);
+			_la = _input.LA(1);
+			if (_la==AttributeStart) {
+				{
+				setState(403);
+				attributes();
+				}
+			}
+
+			setState(406);
+			match(Function_);
+			setState(408);
+			_la = _input.LA(1);
+			if (_la==Ampersand) {
+				{
+				setState(407);
+				match(Ampersand);
+				}
+			}
+
+			setState(410);
+			identifier();
+			setState(412);
+			_la = _input.LA(1);
+			if (_la==Lgeneric) {
+				{
+				setState(411);
+				typeParameterListInBrackets();
+				}
+			}
+
+			setState(414);
+			match(OpenRoundBracket);
+			setState(415);
+			formalParameterList();
+			setState(416);
+			match(CloseRoundBracket);
+			setState(422);
+			_la = _input.LA(1);
+			if (_la==Colon) {
+				{
+				setState(417);
+				match(Colon);
+				setState(419);
+				_la = _input.LA(1);
+				if (_la==QuestionMark) {
+					{
+					setState(418);
+					match(QuestionMark);
+					}
+				}
+
+				setState(421);
+				typeHint(0);
+				}
+			}
+
+			setState(424);
+			blockStatement();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ClassDeclarationContext extends ParserRuleContext {
+		public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); }
+		public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); }
+		public ClassEntryTypeContext classEntryType() {
+			return getRuleContext(ClassEntryTypeContext.class,0);
+		}
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public TerminalNode Interface() { return getToken(PhpParser.Interface, 0); }
+		public AttributesContext attributes() {
+			return getRuleContext(AttributesContext.class,0);
+		}
+		public TerminalNode Private() { return getToken(PhpParser.Private, 0); }
+		public ModifierContext modifier() {
+			return getRuleContext(ModifierContext.class,0);
+		}
+		public TerminalNode Partial() { return getToken(PhpParser.Partial, 0); }
+		public List<ClassStatementContext> classStatement() {
+			return getRuleContexts(ClassStatementContext.class);
+		}
+		public ClassStatementContext classStatement(int i) {
+			return getRuleContext(ClassStatementContext.class,i);
+		}
+		public TypeParameterListInBracketsContext typeParameterListInBrackets() {
+			return getRuleContext(TypeParameterListInBracketsContext.class,0);
+		}
+		public TerminalNode Extends() { return getToken(PhpParser.Extends, 0); }
+		public QualifiedStaticTypeRefContext qualifiedStaticTypeRef() {
+			return getRuleContext(QualifiedStaticTypeRefContext.class,0);
+		}
+		public TerminalNode Implements() { return getToken(PhpParser.Implements, 0); }
+		public InterfaceListContext interfaceList() {
+			return getRuleContext(InterfaceListContext.class,0);
+		}
+		public ClassDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_classDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterClassDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitClassDeclaration(this);
+		}
+	}
+
+	public final ClassDeclarationContext classDeclaration() throws RecognitionException {
+		ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 26, RULE_classDeclaration);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(427);
+			_la = _input.LA(1);
+			if (_la==AttributeStart) {
+				{
+				setState(426);
+				attributes();
+				}
+			}
+
+			setState(430);
+			_la = _input.LA(1);
+			if (_la==Private) {
+				{
+				setState(429);
+				match(Private);
+				}
+			}
+
+			setState(433);
+			_la = _input.LA(1);
+			if (_la==Abstract || _la==Final) {
+				{
+				setState(432);
+				modifier();
+				}
+			}
+
+			setState(436);
+			_la = _input.LA(1);
+			if (_la==Partial) {
+				{
+				setState(435);
+				match(Partial);
+				}
+			}
+
+			setState(460);
+			switch (_input.LA(1)) {
+			case Class:
+			case Trait:
+				{
+				setState(438);
+				classEntryType();
+				setState(439);
+				identifier();
+				setState(441);
+				_la = _input.LA(1);
+				if (_la==Lgeneric) {
+					{
+					setState(440);
+					typeParameterListInBrackets();
+					}
+				}
+
+				setState(445);
+				_la = _input.LA(1);
+				if (_la==Extends) {
+					{
+					setState(443);
+					match(Extends);
+					setState(444);
+					qualifiedStaticTypeRef();
+					}
+				}
+
+				setState(449);
+				_la = _input.LA(1);
+				if (_la==Implements) {
+					{
+					setState(447);
+					match(Implements);
+					setState(448);
+					interfaceList();
+					}
+				}
+
+				}
+				break;
+			case Interface:
+				{
+				setState(451);
+				match(Interface);
+				setState(452);
+				identifier();
+				setState(454);
+				_la = _input.LA(1);
+				if (_la==Lgeneric) {
+					{
+					setState(453);
+					typeParameterListInBrackets();
+					}
+				}
+
+				setState(458);
+				_la = _input.LA(1);
+				if (_la==Extends) {
+					{
+					setState(456);
+					match(Extends);
+					setState(457);
+					interfaceList();
+					}
+				}
+
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+			setState(462);
+			match(OpenCurlyBracket);
+			setState(466);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AttributeStart) | (1L << Abstract) | (1L << Const))) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (Final - 77)) | (1L << (Function_ - 77)) | (1L << (Private - 77)) | (1L << (Protected - 77)) | (1L << (Public - 77)) | (1L << (Readonly - 77)) | (1L << (Static - 77)) | (1L << (Use - 77)) | (1L << (Var - 77)))) != 0)) {
+				{
+				{
+				setState(463);
+				classStatement();
+				}
+				}
+				setState(468);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(469);
+			match(CloseCurlyBracket);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ClassEntryTypeContext extends ParserRuleContext {
+		public TerminalNode Class() { return getToken(PhpParser.Class, 0); }
+		public TerminalNode Trait() { return getToken(PhpParser.Trait, 0); }
+		public ClassEntryTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_classEntryType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterClassEntryType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitClassEntryType(this);
+		}
+	}
+
+	public final ClassEntryTypeContext classEntryType() throws RecognitionException {
+		ClassEntryTypeContext _localctx = new ClassEntryTypeContext(_ctx, getState());
+		enterRule(_localctx, 28, RULE_classEntryType);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(471);
+			_la = _input.LA(1);
+			if ( !(_la==Class || _la==Trait) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InterfaceListContext extends ParserRuleContext {
+		public List<QualifiedStaticTypeRefContext> qualifiedStaticTypeRef() {
+			return getRuleContexts(QualifiedStaticTypeRefContext.class);
+		}
+		public QualifiedStaticTypeRefContext qualifiedStaticTypeRef(int i) {
+			return getRuleContext(QualifiedStaticTypeRefContext.class,i);
+		}
+		public InterfaceListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_interfaceList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterInterfaceList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitInterfaceList(this);
+		}
+	}
+
+	public final InterfaceListContext interfaceList() throws RecognitionException {
+		InterfaceListContext _localctx = new InterfaceListContext(_ctx, getState());
+		enterRule(_localctx, 30, RULE_interfaceList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(473);
+			qualifiedStaticTypeRef();
+			setState(478);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==Comma) {
+				{
+				{
+				setState(474);
+				match(Comma);
+				setState(475);
+				qualifiedStaticTypeRef();
+				}
+				}
+				setState(480);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeParameterListInBracketsContext extends ParserRuleContext {
+		public TypeParameterListContext typeParameterList() {
+			return getRuleContext(TypeParameterListContext.class,0);
+		}
+		public TypeParameterWithDefaultsListContext typeParameterWithDefaultsList() {
+			return getRuleContext(TypeParameterWithDefaultsListContext.class,0);
+		}
+		public TypeParameterListInBracketsContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeParameterListInBrackets; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTypeParameterListInBrackets(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTypeParameterListInBrackets(this);
+		}
+	}
+
+	public final TypeParameterListInBracketsContext typeParameterListInBrackets() throws RecognitionException {
+		TypeParameterListInBracketsContext _localctx = new TypeParameterListInBracketsContext(_ctx, getState());
+		enterRule(_localctx, 32, RULE_typeParameterListInBrackets);
+		try {
+			setState(495);
+			switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(481);
+				match(Lgeneric);
+				setState(482);
+				typeParameterList();
+				setState(483);
+				match(Rgeneric);
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(485);
+				match(Lgeneric);
+				setState(486);
+				typeParameterWithDefaultsList();
+				setState(487);
+				match(Rgeneric);
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(489);
+				match(Lgeneric);
+				setState(490);
+				typeParameterList();
+				setState(491);
+				match(Comma);
+				setState(492);
+				typeParameterWithDefaultsList();
+				setState(493);
+				match(Rgeneric);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeParameterListContext extends ParserRuleContext {
+		public List<TypeParameterDeclContext> typeParameterDecl() {
+			return getRuleContexts(TypeParameterDeclContext.class);
+		}
+		public TypeParameterDeclContext typeParameterDecl(int i) {
+			return getRuleContext(TypeParameterDeclContext.class,i);
+		}
+		public TypeParameterListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeParameterList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTypeParameterList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTypeParameterList(this);
+		}
+	}
+
+	public final TypeParameterListContext typeParameterList() throws RecognitionException {
+		TypeParameterListContext _localctx = new TypeParameterListContext(_ctx, getState());
+		enterRule(_localctx, 34, RULE_typeParameterList);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(497);
+			typeParameterDecl();
+			setState(502);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,37,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(498);
+					match(Comma);
+					setState(499);
+					typeParameterDecl();
+					}
+					} 
+				}
+				setState(504);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,37,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeParameterWithDefaultsListContext extends ParserRuleContext {
+		public List<TypeParameterWithDefaultDeclContext> typeParameterWithDefaultDecl() {
+			return getRuleContexts(TypeParameterWithDefaultDeclContext.class);
+		}
+		public TypeParameterWithDefaultDeclContext typeParameterWithDefaultDecl(int i) {
+			return getRuleContext(TypeParameterWithDefaultDeclContext.class,i);
+		}
+		public TypeParameterWithDefaultsListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeParameterWithDefaultsList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTypeParameterWithDefaultsList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTypeParameterWithDefaultsList(this);
+		}
+	}
+
+	public final TypeParameterWithDefaultsListContext typeParameterWithDefaultsList() throws RecognitionException {
+		TypeParameterWithDefaultsListContext _localctx = new TypeParameterWithDefaultsListContext(_ctx, getState());
+		enterRule(_localctx, 36, RULE_typeParameterWithDefaultsList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(505);
+			typeParameterWithDefaultDecl();
+			setState(510);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==Comma) {
+				{
+				{
+				setState(506);
+				match(Comma);
+				setState(507);
+				typeParameterWithDefaultDecl();
+				}
+				}
+				setState(512);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeParameterDeclContext extends ParserRuleContext {
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public AttributesContext attributes() {
+			return getRuleContext(AttributesContext.class,0);
+		}
+		public TypeParameterDeclContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeParameterDecl; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTypeParameterDecl(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTypeParameterDecl(this);
+		}
+	}
+
+	public final TypeParameterDeclContext typeParameterDecl() throws RecognitionException {
+		TypeParameterDeclContext _localctx = new TypeParameterDeclContext(_ctx, getState());
+		enterRule(_localctx, 38, RULE_typeParameterDecl);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(514);
+			_la = _input.LA(1);
+			if (_la==AttributeStart) {
+				{
+				setState(513);
+				attributes();
+				}
+			}
+
+			setState(516);
+			identifier();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeParameterWithDefaultDeclContext extends ParserRuleContext {
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); }
+		public QualifiedStaticTypeRefContext qualifiedStaticTypeRef() {
+			return getRuleContext(QualifiedStaticTypeRefContext.class,0);
+		}
+		public PrimitiveTypeContext primitiveType() {
+			return getRuleContext(PrimitiveTypeContext.class,0);
+		}
+		public AttributesContext attributes() {
+			return getRuleContext(AttributesContext.class,0);
+		}
+		public TypeParameterWithDefaultDeclContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeParameterWithDefaultDecl; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTypeParameterWithDefaultDecl(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTypeParameterWithDefaultDecl(this);
+		}
+	}
+
+	public final TypeParameterWithDefaultDeclContext typeParameterWithDefaultDecl() throws RecognitionException {
+		TypeParameterWithDefaultDeclContext _localctx = new TypeParameterWithDefaultDeclContext(_ctx, getState());
+		enterRule(_localctx, 40, RULE_typeParameterWithDefaultDecl);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(519);
+			_la = _input.LA(1);
+			if (_la==AttributeStart) {
+				{
+				setState(518);
+				attributes();
+				}
+			}
+
+			setState(521);
+			identifier();
+			setState(522);
+			match(Eq);
+			setState(525);
+			switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
+			case 1:
+				{
+				setState(523);
+				qualifiedStaticTypeRef();
+				}
+				break;
+			case 2:
+				{
+				setState(524);
+				primitiveType();
+				}
+				break;
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class GenericDynamicArgsContext extends ParserRuleContext {
+		public List<TypeRefContext> typeRef() {
+			return getRuleContexts(TypeRefContext.class);
+		}
+		public TypeRefContext typeRef(int i) {
+			return getRuleContext(TypeRefContext.class,i);
+		}
+		public GenericDynamicArgsContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_genericDynamicArgs; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterGenericDynamicArgs(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitGenericDynamicArgs(this);
+		}
+	}
+
+	public final GenericDynamicArgsContext genericDynamicArgs() throws RecognitionException {
+		GenericDynamicArgsContext _localctx = new GenericDynamicArgsContext(_ctx, getState());
+		enterRule(_localctx, 42, RULE_genericDynamicArgs);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(527);
+			match(Lgeneric);
+			setState(528);
+			typeRef();
+			setState(533);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==Comma) {
+				{
+				{
+				setState(529);
+				match(Comma);
+				setState(530);
+				typeRef();
+				}
+				}
+				setState(535);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(536);
+			match(Rgeneric);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class AttributesContext extends ParserRuleContext {
+		public List<AttributeGroupContext> attributeGroup() {
+			return getRuleContexts(AttributeGroupContext.class);
+		}
+		public AttributeGroupContext attributeGroup(int i) {
+			return getRuleContext(AttributeGroupContext.class,i);
+		}
+		public AttributesContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_attributes; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAttributes(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAttributes(this);
+		}
+	}
+
+	public final AttributesContext attributes() throws RecognitionException {
+		AttributesContext _localctx = new AttributesContext(_ctx, getState());
+		enterRule(_localctx, 44, RULE_attributes);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(539); 
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			do {
+				{
+				{
+				setState(538);
+				attributeGroup();
+				}
+				}
+				setState(541); 
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			} while ( _la==AttributeStart );
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class AttributeGroupContext extends ParserRuleContext {
+		public TerminalNode AttributeStart() { return getToken(PhpParser.AttributeStart, 0); }
+		public List<AttributeContext> attribute() {
+			return getRuleContexts(AttributeContext.class);
+		}
+		public AttributeContext attribute(int i) {
+			return getRuleContext(AttributeContext.class,i);
+		}
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public AttributeGroupContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_attributeGroup; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAttributeGroup(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAttributeGroup(this);
+		}
+	}
+
+	public final AttributeGroupContext attributeGroup() throws RecognitionException {
+		AttributeGroupContext _localctx = new AttributeGroupContext(_ctx, getState());
+		enterRule(_localctx, 46, RULE_attributeGroup);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(543);
+			match(AttributeStart);
+			setState(547);
+			switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
+			case 1:
+				{
+				setState(544);
+				identifier();
+				setState(545);
+				match(Colon);
+				}
+				break;
+			}
+			setState(549);
+			attribute();
+			setState(554);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==Comma) {
+				{
+				{
+				setState(550);
+				match(Comma);
+				setState(551);
+				attribute();
+				}
+				}
+				setState(556);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(557);
+			match(CloseSquareBracket);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class AttributeContext extends ParserRuleContext {
+		public QualifiedNamespaceNameContext qualifiedNamespaceName() {
+			return getRuleContext(QualifiedNamespaceNameContext.class,0);
+		}
+		public ArgumentsContext arguments() {
+			return getRuleContext(ArgumentsContext.class,0);
+		}
+		public AttributeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_attribute; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAttribute(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAttribute(this);
+		}
+	}
+
+	public final AttributeContext attribute() throws RecognitionException {
+		AttributeContext _localctx = new AttributeContext(_ctx, getState());
+		enterRule(_localctx, 48, RULE_attribute);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(559);
+			qualifiedNamespaceName();
+			setState(561);
+			_la = _input.LA(1);
+			if (_la==OpenRoundBracket) {
+				{
+				setState(560);
+				arguments();
+				}
+			}
+
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InnerStatementListContext extends ParserRuleContext {
+		public List<InnerStatementContext> innerStatement() {
+			return getRuleContexts(InnerStatementContext.class);
+		}
+		public InnerStatementContext innerStatement(int i) {
+			return getRuleContext(InnerStatementContext.class,i);
+		}
+		public InnerStatementListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_innerStatementList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterInnerStatementList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitInnerStatementList(this);
+		}
+	}
+
+	public final InnerStatementListContext innerStatementList() throws RecognitionException {
+		InnerStatementListContext _localctx = new InnerStatementListContext(_ctx, getState());
+		enterRule(_localctx, 50, RULE_innerStatementList);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(566);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,47,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(563);
+					innerStatement();
+					}
+					} 
+				}
+				setState(568);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,47,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InnerStatementContext extends ParserRuleContext {
+		public StatementContext statement() {
+			return getRuleContext(StatementContext.class,0);
+		}
+		public FunctionDeclarationContext functionDeclaration() {
+			return getRuleContext(FunctionDeclarationContext.class,0);
+		}
+		public ClassDeclarationContext classDeclaration() {
+			return getRuleContext(ClassDeclarationContext.class,0);
+		}
+		public InnerStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_innerStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterInnerStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitInnerStatement(this);
+		}
+	}
+
+	public final InnerStatementContext innerStatement() throws RecognitionException {
+		InnerStatementContext _localctx = new InnerStatementContext(_ctx, getState());
+		enterRule(_localctx, 52, RULE_innerStatement);
+		try {
+			setState(572);
+			switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(569);
+				statement();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(570);
+				functionDeclaration();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(571);
+				classDeclaration();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class StatementContext extends ParserRuleContext {
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public BlockStatementContext blockStatement() {
+			return getRuleContext(BlockStatementContext.class,0);
+		}
+		public IfStatementContext ifStatement() {
+			return getRuleContext(IfStatementContext.class,0);
+		}
+		public WhileStatementContext whileStatement() {
+			return getRuleContext(WhileStatementContext.class,0);
+		}
+		public DoWhileStatementContext doWhileStatement() {
+			return getRuleContext(DoWhileStatementContext.class,0);
+		}
+		public ForStatementContext forStatement() {
+			return getRuleContext(ForStatementContext.class,0);
+		}
+		public SwitchStatementContext switchStatement() {
+			return getRuleContext(SwitchStatementContext.class,0);
+		}
+		public BreakStatementContext breakStatement() {
+			return getRuleContext(BreakStatementContext.class,0);
+		}
+		public ContinueStatementContext continueStatement() {
+			return getRuleContext(ContinueStatementContext.class,0);
+		}
+		public ReturnStatementContext returnStatement() {
+			return getRuleContext(ReturnStatementContext.class,0);
+		}
+		public YieldExpressionContext yieldExpression() {
+			return getRuleContext(YieldExpressionContext.class,0);
+		}
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public GlobalStatementContext globalStatement() {
+			return getRuleContext(GlobalStatementContext.class,0);
+		}
+		public StaticVariableStatementContext staticVariableStatement() {
+			return getRuleContext(StaticVariableStatementContext.class,0);
+		}
+		public EchoStatementContext echoStatement() {
+			return getRuleContext(EchoStatementContext.class,0);
+		}
+		public ExpressionStatementContext expressionStatement() {
+			return getRuleContext(ExpressionStatementContext.class,0);
+		}
+		public UnsetStatementContext unsetStatement() {
+			return getRuleContext(UnsetStatementContext.class,0);
+		}
+		public ForeachStatementContext foreachStatement() {
+			return getRuleContext(ForeachStatementContext.class,0);
+		}
+		public TryCatchFinallyContext tryCatchFinally() {
+			return getRuleContext(TryCatchFinallyContext.class,0);
+		}
+		public ThrowStatementContext throwStatement() {
+			return getRuleContext(ThrowStatementContext.class,0);
+		}
+		public GotoStatementContext gotoStatement() {
+			return getRuleContext(GotoStatementContext.class,0);
+		}
+		public DeclareStatementContext declareStatement() {
+			return getRuleContext(DeclareStatementContext.class,0);
+		}
+		public EmptyStatement_Context emptyStatement_() {
+			return getRuleContext(EmptyStatement_Context.class,0);
+		}
+		public InlineHtmlStatementContext inlineHtmlStatement() {
+			return getRuleContext(InlineHtmlStatementContext.class,0);
+		}
+		public StatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_statement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitStatement(this);
+		}
+	}
+
+	public final StatementContext statement() throws RecognitionException {
+		StatementContext _localctx = new StatementContext(_ctx, getState());
+		enterRule(_localctx, 54, RULE_statement);
+		try {
+			setState(601);
+			switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(574);
+				identifier();
+				setState(575);
+				match(Colon);
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(577);
+				blockStatement();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(578);
+				ifStatement();
+				}
+				break;
+			case 4:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(579);
+				whileStatement();
+				}
+				break;
+			case 5:
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(580);
+				doWhileStatement();
+				}
+				break;
+			case 6:
+				enterOuterAlt(_localctx, 6);
+				{
+				setState(581);
+				forStatement();
+				}
+				break;
+			case 7:
+				enterOuterAlt(_localctx, 7);
+				{
+				setState(582);
+				switchStatement();
+				}
+				break;
+			case 8:
+				enterOuterAlt(_localctx, 8);
+				{
+				setState(583);
+				breakStatement();
+				}
+				break;
+			case 9:
+				enterOuterAlt(_localctx, 9);
+				{
+				setState(584);
+				continueStatement();
+				}
+				break;
+			case 10:
+				enterOuterAlt(_localctx, 10);
+				{
+				setState(585);
+				returnStatement();
+				}
+				break;
+			case 11:
+				enterOuterAlt(_localctx, 11);
+				{
+				setState(586);
+				yieldExpression();
+				setState(587);
+				match(SemiColon);
+				}
+				break;
+			case 12:
+				enterOuterAlt(_localctx, 12);
+				{
+				setState(589);
+				globalStatement();
+				}
+				break;
+			case 13:
+				enterOuterAlt(_localctx, 13);
+				{
+				setState(590);
+				staticVariableStatement();
+				}
+				break;
+			case 14:
+				enterOuterAlt(_localctx, 14);
+				{
+				setState(591);
+				echoStatement();
+				}
+				break;
+			case 15:
+				enterOuterAlt(_localctx, 15);
+				{
+				setState(592);
+				expressionStatement();
+				}
+				break;
+			case 16:
+				enterOuterAlt(_localctx, 16);
+				{
+				setState(593);
+				unsetStatement();
+				}
+				break;
+			case 17:
+				enterOuterAlt(_localctx, 17);
+				{
+				setState(594);
+				foreachStatement();
+				}
+				break;
+			case 18:
+				enterOuterAlt(_localctx, 18);
+				{
+				setState(595);
+				tryCatchFinally();
+				}
+				break;
+			case 19:
+				enterOuterAlt(_localctx, 19);
+				{
+				setState(596);
+				throwStatement();
+				}
+				break;
+			case 20:
+				enterOuterAlt(_localctx, 20);
+				{
+				setState(597);
+				gotoStatement();
+				}
+				break;
+			case 21:
+				enterOuterAlt(_localctx, 21);
+				{
+				setState(598);
+				declareStatement();
+				}
+				break;
+			case 22:
+				enterOuterAlt(_localctx, 22);
+				{
+				setState(599);
+				emptyStatement_();
+				}
+				break;
+			case 23:
+				enterOuterAlt(_localctx, 23);
+				{
+				setState(600);
+				inlineHtmlStatement();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class EmptyStatement_Context extends ParserRuleContext {
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public EmptyStatement_Context(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_emptyStatement_; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterEmptyStatement_(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitEmptyStatement_(this);
+		}
+	}
+
+	public final EmptyStatement_Context emptyStatement_() throws RecognitionException {
+		EmptyStatement_Context _localctx = new EmptyStatement_Context(_ctx, getState());
+		enterRule(_localctx, 56, RULE_emptyStatement_);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(603);
+			match(SemiColon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class BlockStatementContext extends ParserRuleContext {
+		public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); }
+		public InnerStatementListContext innerStatementList() {
+			return getRuleContext(InnerStatementListContext.class,0);
+		}
+		public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); }
+		public BlockStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_blockStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterBlockStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitBlockStatement(this);
+		}
+	}
+
+	public final BlockStatementContext blockStatement() throws RecognitionException {
+		BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState());
+		enterRule(_localctx, 58, RULE_blockStatement);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(605);
+			match(OpenCurlyBracket);
+			setState(606);
+			innerStatementList();
+			setState(607);
+			match(CloseCurlyBracket);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class IfStatementContext extends ParserRuleContext {
+		public TerminalNode If() { return getToken(PhpParser.If, 0); }
+		public ParenthesesContext parentheses() {
+			return getRuleContext(ParenthesesContext.class,0);
+		}
+		public StatementContext statement() {
+			return getRuleContext(StatementContext.class,0);
+		}
+		public List<ElseIfStatementContext> elseIfStatement() {
+			return getRuleContexts(ElseIfStatementContext.class);
+		}
+		public ElseIfStatementContext elseIfStatement(int i) {
+			return getRuleContext(ElseIfStatementContext.class,i);
+		}
+		public ElseStatementContext elseStatement() {
+			return getRuleContext(ElseStatementContext.class,0);
+		}
+		public InnerStatementListContext innerStatementList() {
+			return getRuleContext(InnerStatementListContext.class,0);
+		}
+		public TerminalNode EndIf() { return getToken(PhpParser.EndIf, 0); }
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public List<ElseIfColonStatementContext> elseIfColonStatement() {
+			return getRuleContexts(ElseIfColonStatementContext.class);
+		}
+		public ElseIfColonStatementContext elseIfColonStatement(int i) {
+			return getRuleContext(ElseIfColonStatementContext.class,i);
+		}
+		public ElseColonStatementContext elseColonStatement() {
+			return getRuleContext(ElseColonStatementContext.class,0);
+		}
+		public IfStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_ifStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterIfStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitIfStatement(this);
+		}
+	}
+
+	public final IfStatementContext ifStatement() throws RecognitionException {
+		IfStatementContext _localctx = new IfStatementContext(_ctx, getState());
+		enterRule(_localctx, 60, RULE_ifStatement);
+		int _la;
+		try {
+			int _alt;
+			setState(637);
+			switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(609);
+				match(If);
+				setState(610);
+				parentheses();
+				setState(611);
+				statement();
+				setState(615);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,50,_ctx);
+				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+					if ( _alt==1 ) {
+						{
+						{
+						setState(612);
+						elseIfStatement();
+						}
+						} 
+					}
+					setState(617);
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,50,_ctx);
+				}
+				setState(619);
+				switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
+				case 1:
+					{
+					setState(618);
+					elseStatement();
+					}
+					break;
+				}
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(621);
+				match(If);
+				setState(622);
+				parentheses();
+				setState(623);
+				match(Colon);
+				setState(624);
+				innerStatementList();
+				setState(628);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==ElseIf) {
+					{
+					{
+					setState(625);
+					elseIfColonStatement();
+					}
+					}
+					setState(630);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(632);
+				_la = _input.LA(1);
+				if (_la==Else) {
+					{
+					setState(631);
+					elseColonStatement();
+					}
+				}
+
+				setState(634);
+				match(EndIf);
+				setState(635);
+				match(SemiColon);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ElseIfStatementContext extends ParserRuleContext {
+		public TerminalNode ElseIf() { return getToken(PhpParser.ElseIf, 0); }
+		public ParenthesesContext parentheses() {
+			return getRuleContext(ParenthesesContext.class,0);
+		}
+		public StatementContext statement() {
+			return getRuleContext(StatementContext.class,0);
+		}
+		public ElseIfStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_elseIfStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterElseIfStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitElseIfStatement(this);
+		}
+	}
+
+	public final ElseIfStatementContext elseIfStatement() throws RecognitionException {
+		ElseIfStatementContext _localctx = new ElseIfStatementContext(_ctx, getState());
+		enterRule(_localctx, 62, RULE_elseIfStatement);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(639);
+			match(ElseIf);
+			setState(640);
+			parentheses();
+			setState(641);
+			statement();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ElseIfColonStatementContext extends ParserRuleContext {
+		public TerminalNode ElseIf() { return getToken(PhpParser.ElseIf, 0); }
+		public ParenthesesContext parentheses() {
+			return getRuleContext(ParenthesesContext.class,0);
+		}
+		public InnerStatementListContext innerStatementList() {
+			return getRuleContext(InnerStatementListContext.class,0);
+		}
+		public ElseIfColonStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_elseIfColonStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterElseIfColonStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitElseIfColonStatement(this);
+		}
+	}
+
+	public final ElseIfColonStatementContext elseIfColonStatement() throws RecognitionException {
+		ElseIfColonStatementContext _localctx = new ElseIfColonStatementContext(_ctx, getState());
+		enterRule(_localctx, 64, RULE_elseIfColonStatement);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(643);
+			match(ElseIf);
+			setState(644);
+			parentheses();
+			setState(645);
+			match(Colon);
+			setState(646);
+			innerStatementList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ElseStatementContext extends ParserRuleContext {
+		public TerminalNode Else() { return getToken(PhpParser.Else, 0); }
+		public StatementContext statement() {
+			return getRuleContext(StatementContext.class,0);
+		}
+		public ElseStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_elseStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterElseStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitElseStatement(this);
+		}
+	}
+
+	public final ElseStatementContext elseStatement() throws RecognitionException {
+		ElseStatementContext _localctx = new ElseStatementContext(_ctx, getState());
+		enterRule(_localctx, 66, RULE_elseStatement);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(648);
+			match(Else);
+			setState(649);
+			statement();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ElseColonStatementContext extends ParserRuleContext {
+		public TerminalNode Else() { return getToken(PhpParser.Else, 0); }
+		public InnerStatementListContext innerStatementList() {
+			return getRuleContext(InnerStatementListContext.class,0);
+		}
+		public ElseColonStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_elseColonStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterElseColonStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitElseColonStatement(this);
+		}
+	}
+
+	public final ElseColonStatementContext elseColonStatement() throws RecognitionException {
+		ElseColonStatementContext _localctx = new ElseColonStatementContext(_ctx, getState());
+		enterRule(_localctx, 68, RULE_elseColonStatement);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(651);
+			match(Else);
+			setState(652);
+			match(Colon);
+			setState(653);
+			innerStatementList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class WhileStatementContext extends ParserRuleContext {
+		public TerminalNode While() { return getToken(PhpParser.While, 0); }
+		public ParenthesesContext parentheses() {
+			return getRuleContext(ParenthesesContext.class,0);
+		}
+		public StatementContext statement() {
+			return getRuleContext(StatementContext.class,0);
+		}
+		public InnerStatementListContext innerStatementList() {
+			return getRuleContext(InnerStatementListContext.class,0);
+		}
+		public TerminalNode EndWhile() { return getToken(PhpParser.EndWhile, 0); }
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public WhileStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_whileStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterWhileStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitWhileStatement(this);
+		}
+	}
+
+	public final WhileStatementContext whileStatement() throws RecognitionException {
+		WhileStatementContext _localctx = new WhileStatementContext(_ctx, getState());
+		enterRule(_localctx, 70, RULE_whileStatement);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(655);
+			match(While);
+			setState(656);
+			parentheses();
+			setState(663);
+			switch (_input.LA(1)) {
+			case HtmlText:
+			case XmlStart:
+			case HtmlScriptOpen:
+			case HtmlStyleOpen:
+			case HtmlDtd:
+			case HtmlOpen:
+			case HtmlClose:
+			case HtmlSlashClose:
+			case HtmlSlash:
+			case HtmlEquals:
+			case HtmlStartQuoteString:
+			case HtmlStartDoubleQuoteString:
+			case HtmlHex:
+			case HtmlDecimal:
+			case HtmlName:
+			case HtmlEndQuoteString:
+			case HtmlQuoteString:
+			case HtmlEndDoubleQuoteString:
+			case HtmlDoubleQuoteString:
+			case ScriptText:
+			case HtmlScriptClose:
+			case StyleBody:
+			case Abstract:
+			case Array:
+			case As:
+			case BinaryCast:
+			case BoolType:
+			case BooleanConstant:
+			case Break:
+			case Callable:
+			case Case:
+			case Catch:
+			case Class:
+			case Clone:
+			case Const:
+			case Continue:
+			case Declare:
+			case Default:
+			case Do:
+			case DoubleCast:
+			case DoubleType:
+			case Echo:
+			case Else:
+			case ElseIf:
+			case Empty:
+			case Enum_:
+			case EndDeclare:
+			case EndFor:
+			case EndForeach:
+			case EndIf:
+			case EndSwitch:
+			case EndWhile:
+			case Eval:
+			case Exit:
+			case Extends:
+			case Final:
+			case Finally:
+			case FloatCast:
+			case For:
+			case Foreach:
+			case Function_:
+			case Global:
+			case Goto:
+			case If:
+			case Implements:
+			case Import:
+			case Include:
+			case IncludeOnce:
+			case InstanceOf:
+			case InsteadOf:
+			case Int8Cast:
+			case Int16Cast:
+			case Int64Type:
+			case IntType:
+			case Interface:
+			case IsSet:
+			case List:
+			case LogicalAnd:
+			case LogicalOr:
+			case LogicalXor:
+			case Match_:
+			case Namespace:
+			case New:
+			case Null:
+			case ObjectType:
+			case Parent_:
+			case Partial:
+			case Print:
+			case Private:
+			case Protected:
+			case Public:
+			case Readonly:
+			case Require:
+			case RequireOnce:
+			case Resource:
+			case Return:
+			case Static:
+			case StringType:
+			case Switch:
+			case Throw:
+			case Trait:
+			case Try:
+			case Typeof:
+			case UintCast:
+			case UnicodeCast:
+			case Unset:
+			case Use:
+			case Var:
+			case While:
+			case Yield:
+			case From:
+			case LambdaFn:
+			case Ticks:
+			case Encoding:
+			case StrictTypes:
+			case Get:
+			case Set:
+			case Call:
+			case CallStatic:
+			case Constructor:
+			case Destruct:
+			case Wakeup:
+			case Sleep:
+			case Autoload:
+			case IsSet__:
+			case Unset__:
+			case ToString__:
+			case Invoke:
+			case SetState:
+			case Clone__:
+			case DebugInfo:
+			case Namespace__:
+			case Class__:
+			case Traic__:
+			case Function__:
+			case Method__:
+			case Line__:
+			case File__:
+			case Dir__:
+			case Inc:
+			case Dec:
+			case NamespaceSeparator:
+			case Bang:
+			case Plus:
+			case Minus:
+			case Tilde:
+			case SuppressWarnings:
+			case Dollar:
+			case OpenRoundBracket:
+			case OpenSquareBracket:
+			case OpenCurlyBracket:
+			case SemiColon:
+			case VarName:
+			case Label:
+			case Octal:
+			case Decimal:
+			case Real:
+			case Hex:
+			case Binary:
+			case BackQuoteString:
+			case SingleQuoteString:
+			case DoubleQuote:
+			case StartNowDoc:
+			case StartHereDoc:
+				{
+				setState(657);
+				statement();
+				}
+				break;
+			case Colon:
+				{
+				setState(658);
+				match(Colon);
+				setState(659);
+				innerStatementList();
+				setState(660);
+				match(EndWhile);
+				setState(661);
+				match(SemiColon);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class DoWhileStatementContext extends ParserRuleContext {
+		public TerminalNode Do() { return getToken(PhpParser.Do, 0); }
+		public StatementContext statement() {
+			return getRuleContext(StatementContext.class,0);
+		}
+		public TerminalNode While() { return getToken(PhpParser.While, 0); }
+		public ParenthesesContext parentheses() {
+			return getRuleContext(ParenthesesContext.class,0);
+		}
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public DoWhileStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_doWhileStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterDoWhileStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitDoWhileStatement(this);
+		}
+	}
+
+	public final DoWhileStatementContext doWhileStatement() throws RecognitionException {
+		DoWhileStatementContext _localctx = new DoWhileStatementContext(_ctx, getState());
+		enterRule(_localctx, 72, RULE_doWhileStatement);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(665);
+			match(Do);
+			setState(666);
+			statement();
+			setState(667);
+			match(While);
+			setState(668);
+			parentheses();
+			setState(669);
+			match(SemiColon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ForStatementContext extends ParserRuleContext {
+		public TerminalNode For() { return getToken(PhpParser.For, 0); }
+		public List<TerminalNode> SemiColon() { return getTokens(PhpParser.SemiColon); }
+		public TerminalNode SemiColon(int i) {
+			return getToken(PhpParser.SemiColon, i);
+		}
+		public StatementContext statement() {
+			return getRuleContext(StatementContext.class,0);
+		}
+		public InnerStatementListContext innerStatementList() {
+			return getRuleContext(InnerStatementListContext.class,0);
+		}
+		public TerminalNode EndFor() { return getToken(PhpParser.EndFor, 0); }
+		public ForInitContext forInit() {
+			return getRuleContext(ForInitContext.class,0);
+		}
+		public ExpressionListContext expressionList() {
+			return getRuleContext(ExpressionListContext.class,0);
+		}
+		public ForUpdateContext forUpdate() {
+			return getRuleContext(ForUpdateContext.class,0);
+		}
+		public ForStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_forStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterForStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitForStatement(this);
+		}
+	}
+
+	public final ForStatementContext forStatement() throws RecognitionException {
+		ForStatementContext _localctx = new ForStatementContext(_ctx, getState());
+		enterRule(_localctx, 74, RULE_forStatement);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(671);
+			match(For);
+			setState(672);
+			match(OpenRoundBracket);
+			setState(674);
+			_la = _input.LA(1);
+			if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) {
+				{
+				setState(673);
+				forInit();
+				}
+			}
+
+			setState(676);
+			match(SemiColon);
+			setState(678);
+			_la = _input.LA(1);
+			if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) {
+				{
+				setState(677);
+				expressionList();
+				}
+			}
+
+			setState(680);
+			match(SemiColon);
+			setState(682);
+			_la = _input.LA(1);
+			if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) {
+				{
+				setState(681);
+				forUpdate();
+				}
+			}
+
+			setState(684);
+			match(CloseRoundBracket);
+			setState(691);
+			switch (_input.LA(1)) {
+			case HtmlText:
+			case XmlStart:
+			case HtmlScriptOpen:
+			case HtmlStyleOpen:
+			case HtmlDtd:
+			case HtmlOpen:
+			case HtmlClose:
+			case HtmlSlashClose:
+			case HtmlSlash:
+			case HtmlEquals:
+			case HtmlStartQuoteString:
+			case HtmlStartDoubleQuoteString:
+			case HtmlHex:
+			case HtmlDecimal:
+			case HtmlName:
+			case HtmlEndQuoteString:
+			case HtmlQuoteString:
+			case HtmlEndDoubleQuoteString:
+			case HtmlDoubleQuoteString:
+			case ScriptText:
+			case HtmlScriptClose:
+			case StyleBody:
+			case Abstract:
+			case Array:
+			case As:
+			case BinaryCast:
+			case BoolType:
+			case BooleanConstant:
+			case Break:
+			case Callable:
+			case Case:
+			case Catch:
+			case Class:
+			case Clone:
+			case Const:
+			case Continue:
+			case Declare:
+			case Default:
+			case Do:
+			case DoubleCast:
+			case DoubleType:
+			case Echo:
+			case Else:
+			case ElseIf:
+			case Empty:
+			case Enum_:
+			case EndDeclare:
+			case EndFor:
+			case EndForeach:
+			case EndIf:
+			case EndSwitch:
+			case EndWhile:
+			case Eval:
+			case Exit:
+			case Extends:
+			case Final:
+			case Finally:
+			case FloatCast:
+			case For:
+			case Foreach:
+			case Function_:
+			case Global:
+			case Goto:
+			case If:
+			case Implements:
+			case Import:
+			case Include:
+			case IncludeOnce:
+			case InstanceOf:
+			case InsteadOf:
+			case Int8Cast:
+			case Int16Cast:
+			case Int64Type:
+			case IntType:
+			case Interface:
+			case IsSet:
+			case List:
+			case LogicalAnd:
+			case LogicalOr:
+			case LogicalXor:
+			case Match_:
+			case Namespace:
+			case New:
+			case Null:
+			case ObjectType:
+			case Parent_:
+			case Partial:
+			case Print:
+			case Private:
+			case Protected:
+			case Public:
+			case Readonly:
+			case Require:
+			case RequireOnce:
+			case Resource:
+			case Return:
+			case Static:
+			case StringType:
+			case Switch:
+			case Throw:
+			case Trait:
+			case Try:
+			case Typeof:
+			case UintCast:
+			case UnicodeCast:
+			case Unset:
+			case Use:
+			case Var:
+			case While:
+			case Yield:
+			case From:
+			case LambdaFn:
+			case Ticks:
+			case Encoding:
+			case StrictTypes:
+			case Get:
+			case Set:
+			case Call:
+			case CallStatic:
+			case Constructor:
+			case Destruct:
+			case Wakeup:
+			case Sleep:
+			case Autoload:
+			case IsSet__:
+			case Unset__:
+			case ToString__:
+			case Invoke:
+			case SetState:
+			case Clone__:
+			case DebugInfo:
+			case Namespace__:
+			case Class__:
+			case Traic__:
+			case Function__:
+			case Method__:
+			case Line__:
+			case File__:
+			case Dir__:
+			case Inc:
+			case Dec:
+			case NamespaceSeparator:
+			case Bang:
+			case Plus:
+			case Minus:
+			case Tilde:
+			case SuppressWarnings:
+			case Dollar:
+			case OpenRoundBracket:
+			case OpenSquareBracket:
+			case OpenCurlyBracket:
+			case SemiColon:
+			case VarName:
+			case Label:
+			case Octal:
+			case Decimal:
+			case Real:
+			case Hex:
+			case Binary:
+			case BackQuoteString:
+			case SingleQuoteString:
+			case DoubleQuote:
+			case StartNowDoc:
+			case StartHereDoc:
+				{
+				setState(685);
+				statement();
+				}
+				break;
+			case Colon:
+				{
+				setState(686);
+				match(Colon);
+				setState(687);
+				innerStatementList();
+				setState(688);
+				match(EndFor);
+				setState(689);
+				match(SemiColon);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ForInitContext extends ParserRuleContext {
+		public ExpressionListContext expressionList() {
+			return getRuleContext(ExpressionListContext.class,0);
+		}
+		public ForInitContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_forInit; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterForInit(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitForInit(this);
+		}
+	}
+
+	public final ForInitContext forInit() throws RecognitionException {
+		ForInitContext _localctx = new ForInitContext(_ctx, getState());
+		enterRule(_localctx, 76, RULE_forInit);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(693);
+			expressionList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ForUpdateContext extends ParserRuleContext {
+		public ExpressionListContext expressionList() {
+			return getRuleContext(ExpressionListContext.class,0);
+		}
+		public ForUpdateContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_forUpdate; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterForUpdate(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitForUpdate(this);
+		}
+	}
+
+	public final ForUpdateContext forUpdate() throws RecognitionException {
+		ForUpdateContext _localctx = new ForUpdateContext(_ctx, getState());
+		enterRule(_localctx, 78, RULE_forUpdate);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(695);
+			expressionList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class SwitchStatementContext extends ParserRuleContext {
+		public TerminalNode Switch() { return getToken(PhpParser.Switch, 0); }
+		public ParenthesesContext parentheses() {
+			return getRuleContext(ParenthesesContext.class,0);
+		}
+		public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); }
+		public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); }
+		public TerminalNode EndSwitch() { return getToken(PhpParser.EndSwitch, 0); }
+		public List<TerminalNode> SemiColon() { return getTokens(PhpParser.SemiColon); }
+		public TerminalNode SemiColon(int i) {
+			return getToken(PhpParser.SemiColon, i);
+		}
+		public List<SwitchBlockContext> switchBlock() {
+			return getRuleContexts(SwitchBlockContext.class);
+		}
+		public SwitchBlockContext switchBlock(int i) {
+			return getRuleContext(SwitchBlockContext.class,i);
+		}
+		public SwitchStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_switchStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterSwitchStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitSwitchStatement(this);
+		}
+	}
+
+	public final SwitchStatementContext switchStatement() throws RecognitionException {
+		SwitchStatementContext _localctx = new SwitchStatementContext(_ctx, getState());
+		enterRule(_localctx, 80, RULE_switchStatement);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(697);
+			match(Switch);
+			setState(698);
+			parentheses();
+			setState(722);
+			switch (_input.LA(1)) {
+			case OpenCurlyBracket:
+				{
+				setState(699);
+				match(OpenCurlyBracket);
+				setState(701);
+				_la = _input.LA(1);
+				if (_la==SemiColon) {
+					{
+					setState(700);
+					match(SemiColon);
+					}
+				}
+
+				setState(706);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==Case || _la==Default) {
+					{
+					{
+					setState(703);
+					switchBlock();
+					}
+					}
+					setState(708);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(709);
+				match(CloseCurlyBracket);
+				}
+				break;
+			case Colon:
+				{
+				setState(710);
+				match(Colon);
+				setState(712);
+				_la = _input.LA(1);
+				if (_la==SemiColon) {
+					{
+					setState(711);
+					match(SemiColon);
+					}
+				}
+
+				setState(717);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==Case || _la==Default) {
+					{
+					{
+					setState(714);
+					switchBlock();
+					}
+					}
+					setState(719);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(720);
+				match(EndSwitch);
+				setState(721);
+				match(SemiColon);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class SwitchBlockContext extends ParserRuleContext {
+		public InnerStatementListContext innerStatementList() {
+			return getRuleContext(InnerStatementListContext.class,0);
+		}
+		public List<TerminalNode> SemiColon() { return getTokens(PhpParser.SemiColon); }
+		public TerminalNode SemiColon(int i) {
+			return getToken(PhpParser.SemiColon, i);
+		}
+		public List<TerminalNode> Case() { return getTokens(PhpParser.Case); }
+		public TerminalNode Case(int i) {
+			return getToken(PhpParser.Case, i);
+		}
+		public List<ExpressionContext> expression() {
+			return getRuleContexts(ExpressionContext.class);
+		}
+		public ExpressionContext expression(int i) {
+			return getRuleContext(ExpressionContext.class,i);
+		}
+		public List<TerminalNode> Default() { return getTokens(PhpParser.Default); }
+		public TerminalNode Default(int i) {
+			return getToken(PhpParser.Default, i);
+		}
+		public SwitchBlockContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_switchBlock; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterSwitchBlock(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitSwitchBlock(this);
+		}
+	}
+
+	public final SwitchBlockContext switchBlock() throws RecognitionException {
+		SwitchBlockContext _localctx = new SwitchBlockContext(_ctx, getState());
+		enterRule(_localctx, 82, RULE_switchBlock);
+		int _la;
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(730); 
+			_errHandler.sync(this);
+			_alt = 1;
+			do {
+				switch (_alt) {
+				case 1:
+					{
+					{
+					setState(727);
+					switch (_input.LA(1)) {
+					case Case:
+						{
+						setState(724);
+						match(Case);
+						setState(725);
+						expression(0);
+						}
+						break;
+					case Default:
+						{
+						setState(726);
+						match(Default);
+						}
+						break;
+					default:
+						throw new NoViableAltException(this);
+					}
+					setState(729);
+					_la = _input.LA(1);
+					if ( !(_la==Colon || _la==SemiColon) ) {
+					_errHandler.recoverInline(this);
+					} else {
+						consume();
+					}
+					}
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				setState(732); 
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,66,_ctx);
+			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+			setState(734);
+			innerStatementList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class BreakStatementContext extends ParserRuleContext {
+		public TerminalNode Break() { return getToken(PhpParser.Break, 0); }
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public BreakStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_breakStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterBreakStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitBreakStatement(this);
+		}
+	}
+
+	public final BreakStatementContext breakStatement() throws RecognitionException {
+		BreakStatementContext _localctx = new BreakStatementContext(_ctx, getState());
+		enterRule(_localctx, 84, RULE_breakStatement);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(736);
+			match(Break);
+			setState(738);
+			_la = _input.LA(1);
+			if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) {
+				{
+				setState(737);
+				expression(0);
+				}
+			}
+
+			setState(740);
+			match(SemiColon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ContinueStatementContext extends ParserRuleContext {
+		public TerminalNode Continue() { return getToken(PhpParser.Continue, 0); }
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public ContinueStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_continueStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterContinueStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitContinueStatement(this);
+		}
+	}
+
+	public final ContinueStatementContext continueStatement() throws RecognitionException {
+		ContinueStatementContext _localctx = new ContinueStatementContext(_ctx, getState());
+		enterRule(_localctx, 86, RULE_continueStatement);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(742);
+			match(Continue);
+			setState(744);
+			_la = _input.LA(1);
+			if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) {
+				{
+				setState(743);
+				expression(0);
+				}
+			}
+
+			setState(746);
+			match(SemiColon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ReturnStatementContext extends ParserRuleContext {
+		public TerminalNode Return() { return getToken(PhpParser.Return, 0); }
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public ReturnStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_returnStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterReturnStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitReturnStatement(this);
+		}
+	}
+
+	public final ReturnStatementContext returnStatement() throws RecognitionException {
+		ReturnStatementContext _localctx = new ReturnStatementContext(_ctx, getState());
+		enterRule(_localctx, 88, RULE_returnStatement);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(748);
+			match(Return);
+			setState(750);
+			_la = _input.LA(1);
+			if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) {
+				{
+				setState(749);
+				expression(0);
+				}
+			}
+
+			setState(752);
+			match(SemiColon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ExpressionStatementContext extends ParserRuleContext {
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public ExpressionStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_expressionStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterExpressionStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitExpressionStatement(this);
+		}
+	}
+
+	public final ExpressionStatementContext expressionStatement() throws RecognitionException {
+		ExpressionStatementContext _localctx = new ExpressionStatementContext(_ctx, getState());
+		enterRule(_localctx, 90, RULE_expressionStatement);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(754);
+			expression(0);
+			setState(755);
+			match(SemiColon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class UnsetStatementContext extends ParserRuleContext {
+		public TerminalNode Unset() { return getToken(PhpParser.Unset, 0); }
+		public ChainListContext chainList() {
+			return getRuleContext(ChainListContext.class,0);
+		}
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public UnsetStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_unsetStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterUnsetStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitUnsetStatement(this);
+		}
+	}
+
+	public final UnsetStatementContext unsetStatement() throws RecognitionException {
+		UnsetStatementContext _localctx = new UnsetStatementContext(_ctx, getState());
+		enterRule(_localctx, 92, RULE_unsetStatement);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(757);
+			match(Unset);
+			setState(758);
+			match(OpenRoundBracket);
+			setState(759);
+			chainList();
+			setState(760);
+			match(CloseRoundBracket);
+			setState(761);
+			match(SemiColon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ForeachStatementContext extends ParserRuleContext {
+		public TerminalNode Foreach() { return getToken(PhpParser.Foreach, 0); }
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public TerminalNode As() { return getToken(PhpParser.As, 0); }
+		public ArrayDestructuringContext arrayDestructuring() {
+			return getRuleContext(ArrayDestructuringContext.class,0);
+		}
+		public List<ChainContext> chain() {
+			return getRuleContexts(ChainContext.class);
+		}
+		public ChainContext chain(int i) {
+			return getRuleContext(ChainContext.class,i);
+		}
+		public AssignableContext assignable() {
+			return getRuleContext(AssignableContext.class,0);
+		}
+		public TerminalNode List() { return getToken(PhpParser.List, 0); }
+		public AssignmentListContext assignmentList() {
+			return getRuleContext(AssignmentListContext.class,0);
+		}
+		public StatementContext statement() {
+			return getRuleContext(StatementContext.class,0);
+		}
+		public InnerStatementListContext innerStatementList() {
+			return getRuleContext(InnerStatementListContext.class,0);
+		}
+		public TerminalNode EndForeach() { return getToken(PhpParser.EndForeach, 0); }
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public ForeachStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_foreachStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterForeachStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitForeachStatement(this);
+		}
+	}
+
+	public final ForeachStatementContext foreachStatement() throws RecognitionException {
+		ForeachStatementContext _localctx = new ForeachStatementContext(_ctx, getState());
+		enterRule(_localctx, 94, RULE_foreachStatement);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(763);
+			match(Foreach);
+			setState(808);
+			switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
+			case 1:
+				{
+				setState(764);
+				match(OpenRoundBracket);
+				setState(765);
+				expression(0);
+				setState(766);
+				match(As);
+				setState(767);
+				arrayDestructuring();
+				setState(768);
+				match(CloseRoundBracket);
+				}
+				break;
+			case 2:
+				{
+				setState(770);
+				match(OpenRoundBracket);
+				setState(771);
+				chain();
+				setState(772);
+				match(As);
+				setState(774);
+				_la = _input.LA(1);
+				if (_la==Ampersand) {
+					{
+					setState(773);
+					match(Ampersand);
+					}
+				}
+
+				setState(776);
+				assignable();
+				setState(782);
+				_la = _input.LA(1);
+				if (_la==DoubleArrow) {
+					{
+					setState(777);
+					match(DoubleArrow);
+					setState(779);
+					_la = _input.LA(1);
+					if (_la==Ampersand) {
+						{
+						setState(778);
+						match(Ampersand);
+						}
+					}
+
+					setState(781);
+					chain();
+					}
+				}
+
+				setState(784);
+				match(CloseRoundBracket);
+				}
+				break;
+			case 3:
+				{
+				setState(786);
+				match(OpenRoundBracket);
+				setState(787);
+				expression(0);
+				setState(788);
+				match(As);
+				setState(789);
+				assignable();
+				setState(795);
+				_la = _input.LA(1);
+				if (_la==DoubleArrow) {
+					{
+					setState(790);
+					match(DoubleArrow);
+					setState(792);
+					_la = _input.LA(1);
+					if (_la==Ampersand) {
+						{
+						setState(791);
+						match(Ampersand);
+						}
+					}
+
+					setState(794);
+					chain();
+					}
+				}
+
+				setState(797);
+				match(CloseRoundBracket);
+				}
+				break;
+			case 4:
+				{
+				setState(799);
+				match(OpenRoundBracket);
+				setState(800);
+				chain();
+				setState(801);
+				match(As);
+				setState(802);
+				match(List);
+				setState(803);
+				match(OpenRoundBracket);
+				setState(804);
+				assignmentList();
+				setState(805);
+				match(CloseRoundBracket);
+				setState(806);
+				match(CloseRoundBracket);
+				}
+				break;
+			}
+			setState(816);
+			switch (_input.LA(1)) {
+			case HtmlText:
+			case XmlStart:
+			case HtmlScriptOpen:
+			case HtmlStyleOpen:
+			case HtmlDtd:
+			case HtmlOpen:
+			case HtmlClose:
+			case HtmlSlashClose:
+			case HtmlSlash:
+			case HtmlEquals:
+			case HtmlStartQuoteString:
+			case HtmlStartDoubleQuoteString:
+			case HtmlHex:
+			case HtmlDecimal:
+			case HtmlName:
+			case HtmlEndQuoteString:
+			case HtmlQuoteString:
+			case HtmlEndDoubleQuoteString:
+			case HtmlDoubleQuoteString:
+			case ScriptText:
+			case HtmlScriptClose:
+			case StyleBody:
+			case Abstract:
+			case Array:
+			case As:
+			case BinaryCast:
+			case BoolType:
+			case BooleanConstant:
+			case Break:
+			case Callable:
+			case Case:
+			case Catch:
+			case Class:
+			case Clone:
+			case Const:
+			case Continue:
+			case Declare:
+			case Default:
+			case Do:
+			case DoubleCast:
+			case DoubleType:
+			case Echo:
+			case Else:
+			case ElseIf:
+			case Empty:
+			case Enum_:
+			case EndDeclare:
+			case EndFor:
+			case EndForeach:
+			case EndIf:
+			case EndSwitch:
+			case EndWhile:
+			case Eval:
+			case Exit:
+			case Extends:
+			case Final:
+			case Finally:
+			case FloatCast:
+			case For:
+			case Foreach:
+			case Function_:
+			case Global:
+			case Goto:
+			case If:
+			case Implements:
+			case Import:
+			case Include:
+			case IncludeOnce:
+			case InstanceOf:
+			case InsteadOf:
+			case Int8Cast:
+			case Int16Cast:
+			case Int64Type:
+			case IntType:
+			case Interface:
+			case IsSet:
+			case List:
+			case LogicalAnd:
+			case LogicalOr:
+			case LogicalXor:
+			case Match_:
+			case Namespace:
+			case New:
+			case Null:
+			case ObjectType:
+			case Parent_:
+			case Partial:
+			case Print:
+			case Private:
+			case Protected:
+			case Public:
+			case Readonly:
+			case Require:
+			case RequireOnce:
+			case Resource:
+			case Return:
+			case Static:
+			case StringType:
+			case Switch:
+			case Throw:
+			case Trait:
+			case Try:
+			case Typeof:
+			case UintCast:
+			case UnicodeCast:
+			case Unset:
+			case Use:
+			case Var:
+			case While:
+			case Yield:
+			case From:
+			case LambdaFn:
+			case Ticks:
+			case Encoding:
+			case StrictTypes:
+			case Get:
+			case Set:
+			case Call:
+			case CallStatic:
+			case Constructor:
+			case Destruct:
+			case Wakeup:
+			case Sleep:
+			case Autoload:
+			case IsSet__:
+			case Unset__:
+			case ToString__:
+			case Invoke:
+			case SetState:
+			case Clone__:
+			case DebugInfo:
+			case Namespace__:
+			case Class__:
+			case Traic__:
+			case Function__:
+			case Method__:
+			case Line__:
+			case File__:
+			case Dir__:
+			case Inc:
+			case Dec:
+			case NamespaceSeparator:
+			case Bang:
+			case Plus:
+			case Minus:
+			case Tilde:
+			case SuppressWarnings:
+			case Dollar:
+			case OpenRoundBracket:
+			case OpenSquareBracket:
+			case OpenCurlyBracket:
+			case SemiColon:
+			case VarName:
+			case Label:
+			case Octal:
+			case Decimal:
+			case Real:
+			case Hex:
+			case Binary:
+			case BackQuoteString:
+			case SingleQuoteString:
+			case DoubleQuote:
+			case StartNowDoc:
+			case StartHereDoc:
+				{
+				setState(810);
+				statement();
+				}
+				break;
+			case Colon:
+				{
+				setState(811);
+				match(Colon);
+				setState(812);
+				innerStatementList();
+				setState(813);
+				match(EndForeach);
+				setState(814);
+				match(SemiColon);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TryCatchFinallyContext extends ParserRuleContext {
+		public TerminalNode Try() { return getToken(PhpParser.Try, 0); }
+		public BlockStatementContext blockStatement() {
+			return getRuleContext(BlockStatementContext.class,0);
+		}
+		public FinallyStatementContext finallyStatement() {
+			return getRuleContext(FinallyStatementContext.class,0);
+		}
+		public List<CatchClauseContext> catchClause() {
+			return getRuleContexts(CatchClauseContext.class);
+		}
+		public CatchClauseContext catchClause(int i) {
+			return getRuleContext(CatchClauseContext.class,i);
+		}
+		public TryCatchFinallyContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_tryCatchFinally; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTryCatchFinally(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTryCatchFinally(this);
+		}
+	}
+
+	public final TryCatchFinallyContext tryCatchFinally() throws RecognitionException {
+		TryCatchFinallyContext _localctx = new TryCatchFinallyContext(_ctx, getState());
+		enterRule(_localctx, 96, RULE_tryCatchFinally);
+		int _la;
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(818);
+			match(Try);
+			setState(819);
+			blockStatement();
+			setState(835);
+			switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
+			case 1:
+				{
+				setState(821); 
+				_errHandler.sync(this);
+				_alt = 1;
+				do {
+					switch (_alt) {
+					case 1:
+						{
+						{
+						setState(820);
+						catchClause();
+						}
+						}
+						break;
+					default:
+						throw new NoViableAltException(this);
+					}
+					setState(823); 
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,77,_ctx);
+				} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+				setState(826);
+				switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) {
+				case 1:
+					{
+					setState(825);
+					finallyStatement();
+					}
+					break;
+				}
+				}
+				break;
+			case 2:
+				{
+				setState(831);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==Catch) {
+					{
+					{
+					setState(828);
+					catchClause();
+					}
+					}
+					setState(833);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(834);
+				finallyStatement();
+				}
+				break;
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class CatchClauseContext extends ParserRuleContext {
+		public TerminalNode Catch() { return getToken(PhpParser.Catch, 0); }
+		public List<QualifiedStaticTypeRefContext> qualifiedStaticTypeRef() {
+			return getRuleContexts(QualifiedStaticTypeRefContext.class);
+		}
+		public QualifiedStaticTypeRefContext qualifiedStaticTypeRef(int i) {
+			return getRuleContext(QualifiedStaticTypeRefContext.class,i);
+		}
+		public BlockStatementContext blockStatement() {
+			return getRuleContext(BlockStatementContext.class,0);
+		}
+		public TerminalNode VarName() { return getToken(PhpParser.VarName, 0); }
+		public CatchClauseContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_catchClause; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterCatchClause(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitCatchClause(this);
+		}
+	}
+
+	public final CatchClauseContext catchClause() throws RecognitionException {
+		CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState());
+		enterRule(_localctx, 98, RULE_catchClause);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(837);
+			match(Catch);
+			setState(838);
+			match(OpenRoundBracket);
+			setState(839);
+			qualifiedStaticTypeRef();
+			setState(844);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==Pipe) {
+				{
+				{
+				setState(840);
+				match(Pipe);
+				setState(841);
+				qualifiedStaticTypeRef();
+				}
+				}
+				setState(846);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(848);
+			_la = _input.LA(1);
+			if (_la==VarName) {
+				{
+				setState(847);
+				match(VarName);
+				}
+			}
+
+			setState(850);
+			match(CloseRoundBracket);
+			setState(851);
+			blockStatement();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class FinallyStatementContext extends ParserRuleContext {
+		public TerminalNode Finally() { return getToken(PhpParser.Finally, 0); }
+		public BlockStatementContext blockStatement() {
+			return getRuleContext(BlockStatementContext.class,0);
+		}
+		public FinallyStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_finallyStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterFinallyStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitFinallyStatement(this);
+		}
+	}
+
+	public final FinallyStatementContext finallyStatement() throws RecognitionException {
+		FinallyStatementContext _localctx = new FinallyStatementContext(_ctx, getState());
+		enterRule(_localctx, 100, RULE_finallyStatement);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(853);
+			match(Finally);
+			setState(854);
+			blockStatement();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ThrowStatementContext extends ParserRuleContext {
+		public TerminalNode Throw() { return getToken(PhpParser.Throw, 0); }
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public ThrowStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_throwStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterThrowStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitThrowStatement(this);
+		}
+	}
+
+	public final ThrowStatementContext throwStatement() throws RecognitionException {
+		ThrowStatementContext _localctx = new ThrowStatementContext(_ctx, getState());
+		enterRule(_localctx, 102, RULE_throwStatement);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(856);
+			match(Throw);
+			setState(857);
+			expression(0);
+			setState(858);
+			match(SemiColon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class GotoStatementContext extends ParserRuleContext {
+		public TerminalNode Goto() { return getToken(PhpParser.Goto, 0); }
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public GotoStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_gotoStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterGotoStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitGotoStatement(this);
+		}
+	}
+
+	public final GotoStatementContext gotoStatement() throws RecognitionException {
+		GotoStatementContext _localctx = new GotoStatementContext(_ctx, getState());
+		enterRule(_localctx, 104, RULE_gotoStatement);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(860);
+			match(Goto);
+			setState(861);
+			identifier();
+			setState(862);
+			match(SemiColon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class DeclareStatementContext extends ParserRuleContext {
+		public TerminalNode Declare() { return getToken(PhpParser.Declare, 0); }
+		public DeclareListContext declareList() {
+			return getRuleContext(DeclareListContext.class,0);
+		}
+		public StatementContext statement() {
+			return getRuleContext(StatementContext.class,0);
+		}
+		public InnerStatementListContext innerStatementList() {
+			return getRuleContext(InnerStatementListContext.class,0);
+		}
+		public TerminalNode EndDeclare() { return getToken(PhpParser.EndDeclare, 0); }
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public DeclareStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_declareStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterDeclareStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitDeclareStatement(this);
+		}
+	}
+
+	public final DeclareStatementContext declareStatement() throws RecognitionException {
+		DeclareStatementContext _localctx = new DeclareStatementContext(_ctx, getState());
+		enterRule(_localctx, 106, RULE_declareStatement);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(864);
+			match(Declare);
+			setState(865);
+			match(OpenRoundBracket);
+			setState(866);
+			declareList();
+			setState(867);
+			match(CloseRoundBracket);
+			setState(874);
+			switch (_input.LA(1)) {
+			case HtmlText:
+			case XmlStart:
+			case HtmlScriptOpen:
+			case HtmlStyleOpen:
+			case HtmlDtd:
+			case HtmlOpen:
+			case HtmlClose:
+			case HtmlSlashClose:
+			case HtmlSlash:
+			case HtmlEquals:
+			case HtmlStartQuoteString:
+			case HtmlStartDoubleQuoteString:
+			case HtmlHex:
+			case HtmlDecimal:
+			case HtmlName:
+			case HtmlEndQuoteString:
+			case HtmlQuoteString:
+			case HtmlEndDoubleQuoteString:
+			case HtmlDoubleQuoteString:
+			case ScriptText:
+			case HtmlScriptClose:
+			case StyleBody:
+			case Abstract:
+			case Array:
+			case As:
+			case BinaryCast:
+			case BoolType:
+			case BooleanConstant:
+			case Break:
+			case Callable:
+			case Case:
+			case Catch:
+			case Class:
+			case Clone:
+			case Const:
+			case Continue:
+			case Declare:
+			case Default:
+			case Do:
+			case DoubleCast:
+			case DoubleType:
+			case Echo:
+			case Else:
+			case ElseIf:
+			case Empty:
+			case Enum_:
+			case EndDeclare:
+			case EndFor:
+			case EndForeach:
+			case EndIf:
+			case EndSwitch:
+			case EndWhile:
+			case Eval:
+			case Exit:
+			case Extends:
+			case Final:
+			case Finally:
+			case FloatCast:
+			case For:
+			case Foreach:
+			case Function_:
+			case Global:
+			case Goto:
+			case If:
+			case Implements:
+			case Import:
+			case Include:
+			case IncludeOnce:
+			case InstanceOf:
+			case InsteadOf:
+			case Int8Cast:
+			case Int16Cast:
+			case Int64Type:
+			case IntType:
+			case Interface:
+			case IsSet:
+			case List:
+			case LogicalAnd:
+			case LogicalOr:
+			case LogicalXor:
+			case Match_:
+			case Namespace:
+			case New:
+			case Null:
+			case ObjectType:
+			case Parent_:
+			case Partial:
+			case Print:
+			case Private:
+			case Protected:
+			case Public:
+			case Readonly:
+			case Require:
+			case RequireOnce:
+			case Resource:
+			case Return:
+			case Static:
+			case StringType:
+			case Switch:
+			case Throw:
+			case Trait:
+			case Try:
+			case Typeof:
+			case UintCast:
+			case UnicodeCast:
+			case Unset:
+			case Use:
+			case Var:
+			case While:
+			case Yield:
+			case From:
+			case LambdaFn:
+			case Ticks:
+			case Encoding:
+			case StrictTypes:
+			case Get:
+			case Set:
+			case Call:
+			case CallStatic:
+			case Constructor:
+			case Destruct:
+			case Wakeup:
+			case Sleep:
+			case Autoload:
+			case IsSet__:
+			case Unset__:
+			case ToString__:
+			case Invoke:
+			case SetState:
+			case Clone__:
+			case DebugInfo:
+			case Namespace__:
+			case Class__:
+			case Traic__:
+			case Function__:
+			case Method__:
+			case Line__:
+			case File__:
+			case Dir__:
+			case Inc:
+			case Dec:
+			case NamespaceSeparator:
+			case Bang:
+			case Plus:
+			case Minus:
+			case Tilde:
+			case SuppressWarnings:
+			case Dollar:
+			case OpenRoundBracket:
+			case OpenSquareBracket:
+			case OpenCurlyBracket:
+			case SemiColon:
+			case VarName:
+			case Label:
+			case Octal:
+			case Decimal:
+			case Real:
+			case Hex:
+			case Binary:
+			case BackQuoteString:
+			case SingleQuoteString:
+			case DoubleQuote:
+			case StartNowDoc:
+			case StartHereDoc:
+				{
+				setState(868);
+				statement();
+				}
+				break;
+			case Colon:
+				{
+				setState(869);
+				match(Colon);
+				setState(870);
+				innerStatementList();
+				setState(871);
+				match(EndDeclare);
+				setState(872);
+				match(SemiColon);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InlineHtmlStatementContext extends ParserRuleContext {
+		public List<InlineHtmlContext> inlineHtml() {
+			return getRuleContexts(InlineHtmlContext.class);
+		}
+		public InlineHtmlContext inlineHtml(int i) {
+			return getRuleContext(InlineHtmlContext.class,i);
+		}
+		public InlineHtmlStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_inlineHtmlStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterInlineHtmlStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitInlineHtmlStatement(this);
+		}
+	}
+
+	public final InlineHtmlStatementContext inlineHtmlStatement() throws RecognitionException {
+		InlineHtmlStatementContext _localctx = new InlineHtmlStatementContext(_ctx, getState());
+		enterRule(_localctx, 108, RULE_inlineHtmlStatement);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(877); 
+			_errHandler.sync(this);
+			_alt = 1;
+			do {
+				switch (_alt) {
+				case 1:
+					{
+					{
+					setState(876);
+					inlineHtml();
+					}
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				setState(879); 
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,84,_ctx);
+			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class DeclareListContext extends ParserRuleContext {
+		public List<DirectiveContext> directive() {
+			return getRuleContexts(DirectiveContext.class);
+		}
+		public DirectiveContext directive(int i) {
+			return getRuleContext(DirectiveContext.class,i);
+		}
+		public DeclareListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_declareList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterDeclareList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitDeclareList(this);
+		}
+	}
+
+	public final DeclareListContext declareList() throws RecognitionException {
+		DeclareListContext _localctx = new DeclareListContext(_ctx, getState());
+		enterRule(_localctx, 110, RULE_declareList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(881);
+			directive();
+			setState(886);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==Comma) {
+				{
+				{
+				setState(882);
+				match(Comma);
+				setState(883);
+				directive();
+				}
+				}
+				setState(888);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class DirectiveContext extends ParserRuleContext {
+		public TerminalNode Ticks() { return getToken(PhpParser.Ticks, 0); }
+		public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); }
+		public NumericConstantContext numericConstant() {
+			return getRuleContext(NumericConstantContext.class,0);
+		}
+		public TerminalNode Real() { return getToken(PhpParser.Real, 0); }
+		public TerminalNode Encoding() { return getToken(PhpParser.Encoding, 0); }
+		public TerminalNode SingleQuoteString() { return getToken(PhpParser.SingleQuoteString, 0); }
+		public TerminalNode StrictTypes() { return getToken(PhpParser.StrictTypes, 0); }
+		public DirectiveContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_directive; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterDirective(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitDirective(this);
+		}
+	}
+
+	public final DirectiveContext directive() throws RecognitionException {
+		DirectiveContext _localctx = new DirectiveContext(_ctx, getState());
+		enterRule(_localctx, 112, RULE_directive);
+		try {
+			setState(901);
+			switch (_input.LA(1)) {
+			case Ticks:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(889);
+				match(Ticks);
+				setState(890);
+				match(Eq);
+				setState(893);
+				switch (_input.LA(1)) {
+				case Octal:
+				case Decimal:
+				case Hex:
+				case Binary:
+					{
+					setState(891);
+					numericConstant();
+					}
+					break;
+				case Real:
+					{
+					setState(892);
+					match(Real);
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				}
+				break;
+			case Encoding:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(895);
+				match(Encoding);
+				setState(896);
+				match(Eq);
+				setState(897);
+				match(SingleQuoteString);
+				}
+				break;
+			case StrictTypes:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(898);
+				match(StrictTypes);
+				setState(899);
+				match(Eq);
+				setState(900);
+				numericConstant();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class FormalParameterListContext extends ParserRuleContext {
+		public List<FormalParameterContext> formalParameter() {
+			return getRuleContexts(FormalParameterContext.class);
+		}
+		public FormalParameterContext formalParameter(int i) {
+			return getRuleContext(FormalParameterContext.class,i);
+		}
+		public FormalParameterListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_formalParameterList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterFormalParameterList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitFormalParameterList(this);
+		}
+	}
+
+	public final FormalParameterListContext formalParameterList() throws RecognitionException {
+		FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState());
+		enterRule(_localctx, 114, RULE_formalParameterList);
+		int _la;
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(904);
+			_la = _input.LA(1);
+			if (((((_la - 43)) & ~0x3f) == 0 && ((1L << (_la - 43)) & ((1L << (AttributeStart - 43)) | (1L << (Abstract - 43)) | (1L << (Array - 43)) | (1L << (As - 43)) | (1L << (BinaryCast - 43)) | (1L << (BoolType - 43)) | (1L << (BooleanConstant - 43)) | (1L << (Break - 43)) | (1L << (Callable - 43)) | (1L << (Case - 43)) | (1L << (Catch - 43)) | (1L << (Class - 43)) | (1L << (Clone - 43)) | (1L << (Const - 43)) | (1L << (Continue - 43)) | (1L << (Declare - 43)) | (1L << (Default - 43)) | (1L << (Do - 43)) | (1L << (DoubleCast - 43)) | (1L << (DoubleType - 43)) | (1L << (Echo - 43)) | (1L << (Else - 43)) | (1L << (ElseIf - 43)) | (1L << (Empty - 43)) | (1L << (Enum_ - 43)) | (1L << (EndDeclare - 43)) | (1L << (EndFor - 43)) | (1L << (EndForeach - 43)) | (1L << (EndIf - 43)) | (1L << (EndSwitch - 43)) | (1L << (EndWhile - 43)) | (1L << (Eval - 43)) | (1L << (Exit - 43)) | (1L << (Extends - 43)) | (1L << (Final - 43)) | (1L << (Finally - 43)) | (1L << (FloatCast - 43)) | (1L << (For - 43)) | (1L << (Foreach - 43)) | (1L << (Function_ - 43)) | (1L << (Global - 43)) | (1L << (Goto - 43)) | (1L << (If - 43)) | (1L << (Implements - 43)) | (1L << (Import - 43)) | (1L << (Include - 43)) | (1L << (IncludeOnce - 43)) | (1L << (InstanceOf - 43)) | (1L << (InsteadOf - 43)) | (1L << (Int8Cast - 43)) | (1L << (Int16Cast - 43)) | (1L << (Int64Type - 43)) | (1L << (IntType - 43)) | (1L << (Interface - 43)) | (1L << (IsSet - 43)) | (1L << (List - 43)) | (1L << (LogicalAnd - 43)) | (1L << (LogicalOr - 43)) | (1L << (LogicalXor - 43)) | (1L << (Match_ - 43)) | (1L << (Namespace - 43)) | (1L << (New - 43)) | (1L << (Null - 43)) | (1L << (ObjectType - 43)))) != 0) || ((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & ((1L << (Parent_ - 107)) | (1L << (Partial - 107)) | (1L << (Print - 107)) | (1L << (Private - 107)) | (1L << (Protected - 107)) | (1L << (Public - 107)) | (1L << (Readonly - 107)) | (1L << (Require - 107)) | (1L << (RequireOnce - 107)) | (1L << (Resource - 107)) | (1L << (Return - 107)) | (1L << (Static - 107)) | (1L << (StringType - 107)) | (1L << (Switch - 107)) | (1L << (Throw - 107)) | (1L << (Trait - 107)) | (1L << (Try - 107)) | (1L << (Typeof - 107)) | (1L << (UintCast - 107)) | (1L << (UnicodeCast - 107)) | (1L << (Unset - 107)) | (1L << (Use - 107)) | (1L << (Var - 107)) | (1L << (While - 107)) | (1L << (Yield - 107)) | (1L << (From - 107)) | (1L << (LambdaFn - 107)) | (1L << (Ticks - 107)) | (1L << (Encoding - 107)) | (1L << (StrictTypes - 107)) | (1L << (Get - 107)) | (1L << (Set - 107)) | (1L << (Call - 107)) | (1L << (CallStatic - 107)) | (1L << (Constructor - 107)) | (1L << (Destruct - 107)) | (1L << (Wakeup - 107)) | (1L << (Sleep - 107)) | (1L << (Autoload - 107)) | (1L << (IsSet__ - 107)) | (1L << (Unset__ - 107)) | (1L << (ToString__ - 107)) | (1L << (Invoke - 107)) | (1L << (SetState - 107)) | (1L << (Clone__ - 107)) | (1L << (DebugInfo - 107)) | (1L << (Namespace__ - 107)) | (1L << (Class__ - 107)) | (1L << (Traic__ - 107)) | (1L << (Function__ - 107)) | (1L << (Method__ - 107)) | (1L << (Line__ - 107)) | (1L << (File__ - 107)) | (1L << (Dir__ - 107)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Ellipsis - 194)) | (1L << (Ampersand - 194)) | (1L << (QuestionMark - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)))) != 0)) {
+				{
+				setState(903);
+				formalParameter();
+				}
+			}
+
+			setState(910);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,89,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(906);
+					match(Comma);
+					setState(907);
+					formalParameter();
+					}
+					} 
+				}
+				setState(912);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,89,_ctx);
+			}
+			setState(914);
+			_la = _input.LA(1);
+			if (_la==Comma) {
+				{
+				setState(913);
+				match(Comma);
+				}
+			}
+
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class FormalParameterContext extends ParserRuleContext {
+		public VariableInitializerContext variableInitializer() {
+			return getRuleContext(VariableInitializerContext.class,0);
+		}
+		public AttributesContext attributes() {
+			return getRuleContext(AttributesContext.class,0);
+		}
+		public List<MemberModifierContext> memberModifier() {
+			return getRuleContexts(MemberModifierContext.class);
+		}
+		public MemberModifierContext memberModifier(int i) {
+			return getRuleContext(MemberModifierContext.class,i);
+		}
+		public TerminalNode QuestionMark() { return getToken(PhpParser.QuestionMark, 0); }
+		public TypeHintContext typeHint() {
+			return getRuleContext(TypeHintContext.class,0);
+		}
+		public FormalParameterContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_formalParameter; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterFormalParameter(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitFormalParameter(this);
+		}
+	}
+
+	public final FormalParameterContext formalParameter() throws RecognitionException {
+		FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState());
+		enterRule(_localctx, 116, RULE_formalParameter);
+		int _la;
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(917);
+			_la = _input.LA(1);
+			if (_la==AttributeStart) {
+				{
+				setState(916);
+				attributes();
+				}
+			}
+
+			setState(922);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,92,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(919);
+					memberModifier();
+					}
+					} 
+				}
+				setState(924);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,92,_ctx);
+			}
+			setState(926);
+			_la = _input.LA(1);
+			if (_la==QuestionMark) {
+				{
+				setState(925);
+				match(QuestionMark);
+				}
+			}
+
+			setState(929);
+			_la = _input.LA(1);
+			if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)))) != 0) || _la==NamespaceSeparator || _la==Label) {
+				{
+				setState(928);
+				typeHint(0);
+				}
+			}
+
+			setState(932);
+			_la = _input.LA(1);
+			if (_la==Ampersand) {
+				{
+				setState(931);
+				match(Ampersand);
+				}
+			}
+
+			setState(935);
+			_la = _input.LA(1);
+			if (_la==Ellipsis) {
+				{
+				setState(934);
+				match(Ellipsis);
+				}
+			}
+
+			setState(937);
+			variableInitializer();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeHintContext extends ParserRuleContext {
+		public QualifiedStaticTypeRefContext qualifiedStaticTypeRef() {
+			return getRuleContext(QualifiedStaticTypeRefContext.class,0);
+		}
+		public TerminalNode Callable() { return getToken(PhpParser.Callable, 0); }
+		public PrimitiveTypeContext primitiveType() {
+			return getRuleContext(PrimitiveTypeContext.class,0);
+		}
+		public List<TypeHintContext> typeHint() {
+			return getRuleContexts(TypeHintContext.class);
+		}
+		public TypeHintContext typeHint(int i) {
+			return getRuleContext(TypeHintContext.class,i);
+		}
+		public TypeHintContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeHint; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTypeHint(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTypeHint(this);
+		}
+	}
+
+	public final TypeHintContext typeHint() throws RecognitionException {
+		return typeHint(0);
+	}
+
+	private TypeHintContext typeHint(int _p) throws RecognitionException {
+		ParserRuleContext _parentctx = _ctx;
+		int _parentState = getState();
+		TypeHintContext _localctx = new TypeHintContext(_ctx, _parentState);
+		TypeHintContext _prevctx = _localctx;
+		int _startState = 118;
+		enterRecursionRule(_localctx, 118, RULE_typeHint, _p);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(943);
+			switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
+			case 1:
+				{
+				setState(940);
+				qualifiedStaticTypeRef();
+				}
+				break;
+			case 2:
+				{
+				setState(941);
+				match(Callable);
+				}
+				break;
+			case 3:
+				{
+				setState(942);
+				primitiveType();
+				}
+				break;
+			}
+			_ctx.stop = _input.LT(-1);
+			setState(950);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,98,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					if ( _parseListeners!=null ) triggerExitRuleEvent();
+					_prevctx = _localctx;
+					{
+					{
+					_localctx = new TypeHintContext(_parentctx, _parentState);
+					pushNewRecursionContext(_localctx, _startState, RULE_typeHint);
+					setState(945);
+					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
+					setState(946);
+					match(Pipe);
+					setState(947);
+					typeHint(2);
+					}
+					} 
+				}
+				setState(952);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,98,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			unrollRecursionContexts(_parentctx);
+		}
+		return _localctx;
+	}
+
+	public static class GlobalStatementContext extends ParserRuleContext {
+		public TerminalNode Global() { return getToken(PhpParser.Global, 0); }
+		public List<GlobalVarContext> globalVar() {
+			return getRuleContexts(GlobalVarContext.class);
+		}
+		public GlobalVarContext globalVar(int i) {
+			return getRuleContext(GlobalVarContext.class,i);
+		}
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public GlobalStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_globalStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterGlobalStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitGlobalStatement(this);
+		}
+	}
+
+	public final GlobalStatementContext globalStatement() throws RecognitionException {
+		GlobalStatementContext _localctx = new GlobalStatementContext(_ctx, getState());
+		enterRule(_localctx, 120, RULE_globalStatement);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(953);
+			match(Global);
+			setState(954);
+			globalVar();
+			setState(959);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==Comma) {
+				{
+				{
+				setState(955);
+				match(Comma);
+				setState(956);
+				globalVar();
+				}
+				}
+				setState(961);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(962);
+			match(SemiColon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class GlobalVarContext extends ParserRuleContext {
+		public TerminalNode VarName() { return getToken(PhpParser.VarName, 0); }
+		public TerminalNode Dollar() { return getToken(PhpParser.Dollar, 0); }
+		public ChainContext chain() {
+			return getRuleContext(ChainContext.class,0);
+		}
+		public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); }
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); }
+		public GlobalVarContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_globalVar; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterGlobalVar(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitGlobalVar(this);
+		}
+	}
+
+	public final GlobalVarContext globalVar() throws RecognitionException {
+		GlobalVarContext _localctx = new GlobalVarContext(_ctx, getState());
+		enterRule(_localctx, 122, RULE_globalVar);
+		try {
+			setState(972);
+			switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(964);
+				match(VarName);
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(965);
+				match(Dollar);
+				setState(966);
+				chain();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(967);
+				match(Dollar);
+				setState(968);
+				match(OpenCurlyBracket);
+				setState(969);
+				expression(0);
+				setState(970);
+				match(CloseCurlyBracket);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class EchoStatementContext extends ParserRuleContext {
+		public TerminalNode Echo() { return getToken(PhpParser.Echo, 0); }
+		public ExpressionListContext expressionList() {
+			return getRuleContext(ExpressionListContext.class,0);
+		}
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public EchoStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_echoStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterEchoStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitEchoStatement(this);
+		}
+	}
+
+	public final EchoStatementContext echoStatement() throws RecognitionException {
+		EchoStatementContext _localctx = new EchoStatementContext(_ctx, getState());
+		enterRule(_localctx, 124, RULE_echoStatement);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(974);
+			match(Echo);
+			setState(975);
+			expressionList();
+			setState(976);
+			match(SemiColon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class StaticVariableStatementContext extends ParserRuleContext {
+		public TerminalNode Static() { return getToken(PhpParser.Static, 0); }
+		public List<VariableInitializerContext> variableInitializer() {
+			return getRuleContexts(VariableInitializerContext.class);
+		}
+		public VariableInitializerContext variableInitializer(int i) {
+			return getRuleContext(VariableInitializerContext.class,i);
+		}
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public StaticVariableStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_staticVariableStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterStaticVariableStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitStaticVariableStatement(this);
+		}
+	}
+
+	public final StaticVariableStatementContext staticVariableStatement() throws RecognitionException {
+		StaticVariableStatementContext _localctx = new StaticVariableStatementContext(_ctx, getState());
+		enterRule(_localctx, 126, RULE_staticVariableStatement);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(978);
+			match(Static);
+			setState(979);
+			variableInitializer();
+			setState(984);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==Comma) {
+				{
+				{
+				setState(980);
+				match(Comma);
+				setState(981);
+				variableInitializer();
+				}
+				}
+				setState(986);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(987);
+			match(SemiColon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ClassStatementContext extends ParserRuleContext {
+		public PropertyModifiersContext propertyModifiers() {
+			return getRuleContext(PropertyModifiersContext.class,0);
+		}
+		public List<VariableInitializerContext> variableInitializer() {
+			return getRuleContexts(VariableInitializerContext.class);
+		}
+		public VariableInitializerContext variableInitializer(int i) {
+			return getRuleContext(VariableInitializerContext.class,i);
+		}
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public AttributesContext attributes() {
+			return getRuleContext(AttributesContext.class,0);
+		}
+		public TerminalNode Const() { return getToken(PhpParser.Const, 0); }
+		public List<IdentifierInitializerContext> identifierInitializer() {
+			return getRuleContexts(IdentifierInitializerContext.class);
+		}
+		public IdentifierInitializerContext identifierInitializer(int i) {
+			return getRuleContext(IdentifierInitializerContext.class,i);
+		}
+		public TerminalNode Function_() { return getToken(PhpParser.Function_, 0); }
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public FormalParameterListContext formalParameterList() {
+			return getRuleContext(FormalParameterListContext.class,0);
+		}
+		public MethodBodyContext methodBody() {
+			return getRuleContext(MethodBodyContext.class,0);
+		}
+		public TypeHintContext typeHint() {
+			return getRuleContext(TypeHintContext.class,0);
+		}
+		public MemberModifiersContext memberModifiers() {
+			return getRuleContext(MemberModifiersContext.class,0);
+		}
+		public TypeParameterListInBracketsContext typeParameterListInBrackets() {
+			return getRuleContext(TypeParameterListInBracketsContext.class,0);
+		}
+		public BaseCtorCallContext baseCtorCall() {
+			return getRuleContext(BaseCtorCallContext.class,0);
+		}
+		public ReturnTypeDeclContext returnTypeDecl() {
+			return getRuleContext(ReturnTypeDeclContext.class,0);
+		}
+		public TerminalNode Use() { return getToken(PhpParser.Use, 0); }
+		public QualifiedNamespaceNameListContext qualifiedNamespaceNameList() {
+			return getRuleContext(QualifiedNamespaceNameListContext.class,0);
+		}
+		public TraitAdaptationsContext traitAdaptations() {
+			return getRuleContext(TraitAdaptationsContext.class,0);
+		}
+		public ClassStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_classStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterClassStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitClassStatement(this);
+		}
+	}
+
+	public final ClassStatementContext classStatement() throws RecognitionException {
+		ClassStatementContext _localctx = new ClassStatementContext(_ctx, getState());
+		enterRule(_localctx, 128, RULE_classStatement);
+		int _la;
+		try {
+			setState(1048);
+			switch (_input.LA(1)) {
+			case AttributeStart:
+			case Abstract:
+			case Const:
+			case Final:
+			case Function_:
+			case Private:
+			case Protected:
+			case Public:
+			case Readonly:
+			case Static:
+			case Var:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(990);
+				_la = _input.LA(1);
+				if (_la==AttributeStart) {
+					{
+					setState(989);
+					attributes();
+					}
+				}
+
+				setState(1042);
+				switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) {
+				case 1:
+					{
+					setState(992);
+					propertyModifiers();
+					setState(994);
+					_la = _input.LA(1);
+					if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)))) != 0) || _la==NamespaceSeparator || _la==Label) {
+						{
+						setState(993);
+						typeHint(0);
+						}
+					}
+
+					setState(996);
+					variableInitializer();
+					setState(1001);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+					while (_la==Comma) {
+						{
+						{
+						setState(997);
+						match(Comma);
+						setState(998);
+						variableInitializer();
+						}
+						}
+						setState(1003);
+						_errHandler.sync(this);
+						_la = _input.LA(1);
+					}
+					setState(1004);
+					match(SemiColon);
+					}
+					break;
+				case 2:
+					{
+					setState(1007);
+					_la = _input.LA(1);
+					if (_la==Abstract || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (Final - 77)) | (1L << (Private - 77)) | (1L << (Protected - 77)) | (1L << (Public - 77)) | (1L << (Readonly - 77)) | (1L << (Static - 77)))) != 0)) {
+						{
+						setState(1006);
+						memberModifiers();
+						}
+					}
+
+					setState(1040);
+					switch (_input.LA(1)) {
+					case Const:
+						{
+						setState(1009);
+						match(Const);
+						setState(1011);
+						switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) {
+						case 1:
+							{
+							setState(1010);
+							typeHint(0);
+							}
+							break;
+						}
+						setState(1013);
+						identifierInitializer();
+						setState(1018);
+						_errHandler.sync(this);
+						_la = _input.LA(1);
+						while (_la==Comma) {
+							{
+							{
+							setState(1014);
+							match(Comma);
+							setState(1015);
+							identifierInitializer();
+							}
+							}
+							setState(1020);
+							_errHandler.sync(this);
+							_la = _input.LA(1);
+						}
+						setState(1021);
+						match(SemiColon);
+						}
+						break;
+					case Function_:
+						{
+						setState(1023);
+						match(Function_);
+						setState(1025);
+						_la = _input.LA(1);
+						if (_la==Ampersand) {
+							{
+							setState(1024);
+							match(Ampersand);
+							}
+						}
+
+						setState(1027);
+						identifier();
+						setState(1029);
+						_la = _input.LA(1);
+						if (_la==Lgeneric) {
+							{
+							setState(1028);
+							typeParameterListInBrackets();
+							}
+						}
+
+						setState(1031);
+						match(OpenRoundBracket);
+						setState(1032);
+						formalParameterList();
+						setState(1033);
+						match(CloseRoundBracket);
+						setState(1036);
+						switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) {
+						case 1:
+							{
+							setState(1034);
+							baseCtorCall();
+							}
+							break;
+						case 2:
+							{
+							setState(1035);
+							returnTypeDecl();
+							}
+							break;
+						}
+						setState(1038);
+						methodBody();
+						}
+						break;
+					default:
+						throw new NoViableAltException(this);
+					}
+					}
+					break;
+				}
+				}
+				break;
+			case Use:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1044);
+				match(Use);
+				setState(1045);
+				qualifiedNamespaceNameList();
+				setState(1046);
+				traitAdaptations();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TraitAdaptationsContext extends ParserRuleContext {
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); }
+		public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); }
+		public List<TraitAdaptationStatementContext> traitAdaptationStatement() {
+			return getRuleContexts(TraitAdaptationStatementContext.class);
+		}
+		public TraitAdaptationStatementContext traitAdaptationStatement(int i) {
+			return getRuleContext(TraitAdaptationStatementContext.class,i);
+		}
+		public TraitAdaptationsContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_traitAdaptations; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTraitAdaptations(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTraitAdaptations(this);
+		}
+	}
+
+	public final TraitAdaptationsContext traitAdaptations() throws RecognitionException {
+		TraitAdaptationsContext _localctx = new TraitAdaptationsContext(_ctx, getState());
+		enterRule(_localctx, 130, RULE_traitAdaptations);
+		int _la;
+		try {
+			setState(1059);
+			switch (_input.LA(1)) {
+			case SemiColon:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1050);
+				match(SemiColon);
+				}
+				break;
+			case OpenCurlyBracket:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1051);
+				match(OpenCurlyBracket);
+				setState(1055);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)))) != 0) || _la==NamespaceSeparator || _la==Label) {
+					{
+					{
+					setState(1052);
+					traitAdaptationStatement();
+					}
+					}
+					setState(1057);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(1058);
+				match(CloseCurlyBracket);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TraitAdaptationStatementContext extends ParserRuleContext {
+		public TraitPrecedenceContext traitPrecedence() {
+			return getRuleContext(TraitPrecedenceContext.class,0);
+		}
+		public TraitAliasContext traitAlias() {
+			return getRuleContext(TraitAliasContext.class,0);
+		}
+		public TraitAdaptationStatementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_traitAdaptationStatement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTraitAdaptationStatement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTraitAdaptationStatement(this);
+		}
+	}
+
+	public final TraitAdaptationStatementContext traitAdaptationStatement() throws RecognitionException {
+		TraitAdaptationStatementContext _localctx = new TraitAdaptationStatementContext(_ctx, getState());
+		enterRule(_localctx, 132, RULE_traitAdaptationStatement);
+		try {
+			setState(1063);
+			switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1061);
+				traitPrecedence();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1062);
+				traitAlias();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TraitPrecedenceContext extends ParserRuleContext {
+		public QualifiedNamespaceNameContext qualifiedNamespaceName() {
+			return getRuleContext(QualifiedNamespaceNameContext.class,0);
+		}
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public TerminalNode InsteadOf() { return getToken(PhpParser.InsteadOf, 0); }
+		public QualifiedNamespaceNameListContext qualifiedNamespaceNameList() {
+			return getRuleContext(QualifiedNamespaceNameListContext.class,0);
+		}
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public TraitPrecedenceContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_traitPrecedence; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTraitPrecedence(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTraitPrecedence(this);
+		}
+	}
+
+	public final TraitPrecedenceContext traitPrecedence() throws RecognitionException {
+		TraitPrecedenceContext _localctx = new TraitPrecedenceContext(_ctx, getState());
+		enterRule(_localctx, 134, RULE_traitPrecedence);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1065);
+			qualifiedNamespaceName();
+			setState(1066);
+			match(DoubleColon);
+			setState(1067);
+			identifier();
+			setState(1068);
+			match(InsteadOf);
+			setState(1069);
+			qualifiedNamespaceNameList();
+			setState(1070);
+			match(SemiColon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TraitAliasContext extends ParserRuleContext {
+		public TraitMethodReferenceContext traitMethodReference() {
+			return getRuleContext(TraitMethodReferenceContext.class,0);
+		}
+		public TerminalNode As() { return getToken(PhpParser.As, 0); }
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public MemberModifierContext memberModifier() {
+			return getRuleContext(MemberModifierContext.class,0);
+		}
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public TraitAliasContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_traitAlias; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTraitAlias(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTraitAlias(this);
+		}
+	}
+
+	public final TraitAliasContext traitAlias() throws RecognitionException {
+		TraitAliasContext _localctx = new TraitAliasContext(_ctx, getState());
+		enterRule(_localctx, 136, RULE_traitAlias);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1072);
+			traitMethodReference();
+			setState(1073);
+			match(As);
+			setState(1079);
+			switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) {
+			case 1:
+				{
+				setState(1074);
+				memberModifier();
+				}
+				break;
+			case 2:
+				{
+				setState(1076);
+				switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) {
+				case 1:
+					{
+					setState(1075);
+					memberModifier();
+					}
+					break;
+				}
+				setState(1078);
+				identifier();
+				}
+				break;
+			}
+			setState(1081);
+			match(SemiColon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TraitMethodReferenceContext extends ParserRuleContext {
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public QualifiedNamespaceNameContext qualifiedNamespaceName() {
+			return getRuleContext(QualifiedNamespaceNameContext.class,0);
+		}
+		public TraitMethodReferenceContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_traitMethodReference; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTraitMethodReference(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTraitMethodReference(this);
+		}
+	}
+
+	public final TraitMethodReferenceContext traitMethodReference() throws RecognitionException {
+		TraitMethodReferenceContext _localctx = new TraitMethodReferenceContext(_ctx, getState());
+		enterRule(_localctx, 138, RULE_traitMethodReference);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1086);
+			switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) {
+			case 1:
+				{
+				setState(1083);
+				qualifiedNamespaceName();
+				setState(1084);
+				match(DoubleColon);
+				}
+				break;
+			}
+			setState(1088);
+			identifier();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class BaseCtorCallContext extends ParserRuleContext {
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public ArgumentsContext arguments() {
+			return getRuleContext(ArgumentsContext.class,0);
+		}
+		public BaseCtorCallContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_baseCtorCall; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterBaseCtorCall(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitBaseCtorCall(this);
+		}
+	}
+
+	public final BaseCtorCallContext baseCtorCall() throws RecognitionException {
+		BaseCtorCallContext _localctx = new BaseCtorCallContext(_ctx, getState());
+		enterRule(_localctx, 140, RULE_baseCtorCall);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1090);
+			match(Colon);
+			setState(1091);
+			identifier();
+			setState(1093);
+			_la = _input.LA(1);
+			if (_la==OpenRoundBracket) {
+				{
+				setState(1092);
+				arguments();
+				}
+			}
+
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ReturnTypeDeclContext extends ParserRuleContext {
+		public TypeHintContext typeHint() {
+			return getRuleContext(TypeHintContext.class,0);
+		}
+		public TerminalNode QuestionMark() { return getToken(PhpParser.QuestionMark, 0); }
+		public ReturnTypeDeclContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_returnTypeDecl; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterReturnTypeDecl(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitReturnTypeDecl(this);
+		}
+	}
+
+	public final ReturnTypeDeclContext returnTypeDecl() throws RecognitionException {
+		ReturnTypeDeclContext _localctx = new ReturnTypeDeclContext(_ctx, getState());
+		enterRule(_localctx, 142, RULE_returnTypeDecl);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1095);
+			match(Colon);
+			setState(1097);
+			_la = _input.LA(1);
+			if (_la==QuestionMark) {
+				{
+				setState(1096);
+				match(QuestionMark);
+				}
+			}
+
+			setState(1099);
+			typeHint(0);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class MethodBodyContext extends ParserRuleContext {
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public BlockStatementContext blockStatement() {
+			return getRuleContext(BlockStatementContext.class,0);
+		}
+		public MethodBodyContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_methodBody; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMethodBody(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMethodBody(this);
+		}
+	}
+
+	public final MethodBodyContext methodBody() throws RecognitionException {
+		MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState());
+		enterRule(_localctx, 144, RULE_methodBody);
+		try {
+			setState(1103);
+			switch (_input.LA(1)) {
+			case SemiColon:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1101);
+				match(SemiColon);
+				}
+				break;
+			case OpenCurlyBracket:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1102);
+				blockStatement();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class PropertyModifiersContext extends ParserRuleContext {
+		public MemberModifiersContext memberModifiers() {
+			return getRuleContext(MemberModifiersContext.class,0);
+		}
+		public TerminalNode Var() { return getToken(PhpParser.Var, 0); }
+		public PropertyModifiersContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_propertyModifiers; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterPropertyModifiers(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitPropertyModifiers(this);
+		}
+	}
+
+	public final PropertyModifiersContext propertyModifiers() throws RecognitionException {
+		PropertyModifiersContext _localctx = new PropertyModifiersContext(_ctx, getState());
+		enterRule(_localctx, 146, RULE_propertyModifiers);
+		try {
+			setState(1107);
+			switch (_input.LA(1)) {
+			case Abstract:
+			case Final:
+			case Private:
+			case Protected:
+			case Public:
+			case Readonly:
+			case Static:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1105);
+				memberModifiers();
+				}
+				break;
+			case Var:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1106);
+				match(Var);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class MemberModifiersContext extends ParserRuleContext {
+		public List<MemberModifierContext> memberModifier() {
+			return getRuleContexts(MemberModifierContext.class);
+		}
+		public MemberModifierContext memberModifier(int i) {
+			return getRuleContext(MemberModifierContext.class,i);
+		}
+		public MemberModifiersContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_memberModifiers; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMemberModifiers(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMemberModifiers(this);
+		}
+	}
+
+	public final MemberModifiersContext memberModifiers() throws RecognitionException {
+		MemberModifiersContext _localctx = new MemberModifiersContext(_ctx, getState());
+		enterRule(_localctx, 148, RULE_memberModifiers);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1110); 
+			_errHandler.sync(this);
+			_alt = 1;
+			do {
+				switch (_alt) {
+				case 1:
+					{
+					{
+					setState(1109);
+					memberModifier();
+					}
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				setState(1112); 
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,124,_ctx);
+			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class VariableInitializerContext extends ParserRuleContext {
+		public TerminalNode VarName() { return getToken(PhpParser.VarName, 0); }
+		public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); }
+		public ConstantInitializerContext constantInitializer() {
+			return getRuleContext(ConstantInitializerContext.class,0);
+		}
+		public VariableInitializerContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_variableInitializer; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterVariableInitializer(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitVariableInitializer(this);
+		}
+	}
+
+	public final VariableInitializerContext variableInitializer() throws RecognitionException {
+		VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState());
+		enterRule(_localctx, 150, RULE_variableInitializer);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1114);
+			match(VarName);
+			setState(1117);
+			_la = _input.LA(1);
+			if (_la==Eq) {
+				{
+				setState(1115);
+				match(Eq);
+				setState(1116);
+				constantInitializer();
+				}
+			}
+
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class IdentifierInitializerContext extends ParserRuleContext {
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); }
+		public ConstantInitializerContext constantInitializer() {
+			return getRuleContext(ConstantInitializerContext.class,0);
+		}
+		public IdentifierInitializerContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_identifierInitializer; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterIdentifierInitializer(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitIdentifierInitializer(this);
+		}
+	}
+
+	public final IdentifierInitializerContext identifierInitializer() throws RecognitionException {
+		IdentifierInitializerContext _localctx = new IdentifierInitializerContext(_ctx, getState());
+		enterRule(_localctx, 152, RULE_identifierInitializer);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1119);
+			identifier();
+			setState(1120);
+			match(Eq);
+			setState(1121);
+			constantInitializer();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class GlobalConstantDeclarationContext extends ParserRuleContext {
+		public TerminalNode Const() { return getToken(PhpParser.Const, 0); }
+		public List<IdentifierInitializerContext> identifierInitializer() {
+			return getRuleContexts(IdentifierInitializerContext.class);
+		}
+		public IdentifierInitializerContext identifierInitializer(int i) {
+			return getRuleContext(IdentifierInitializerContext.class,i);
+		}
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public AttributesContext attributes() {
+			return getRuleContext(AttributesContext.class,0);
+		}
+		public GlobalConstantDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_globalConstantDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterGlobalConstantDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitGlobalConstantDeclaration(this);
+		}
+	}
+
+	public final GlobalConstantDeclarationContext globalConstantDeclaration() throws RecognitionException {
+		GlobalConstantDeclarationContext _localctx = new GlobalConstantDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 154, RULE_globalConstantDeclaration);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1124);
+			_la = _input.LA(1);
+			if (_la==AttributeStart) {
+				{
+				setState(1123);
+				attributes();
+				}
+			}
+
+			setState(1126);
+			match(Const);
+			setState(1127);
+			identifierInitializer();
+			setState(1132);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==Comma) {
+				{
+				{
+				setState(1128);
+				match(Comma);
+				setState(1129);
+				identifierInitializer();
+				}
+				}
+				setState(1134);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(1135);
+			match(SemiColon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class EnumDeclarationContext extends ParserRuleContext {
+		public TerminalNode Enum_() { return getToken(PhpParser.Enum_, 0); }
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); }
+		public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); }
+		public TerminalNode Colon() { return getToken(PhpParser.Colon, 0); }
+		public TerminalNode Implements() { return getToken(PhpParser.Implements, 0); }
+		public InterfaceListContext interfaceList() {
+			return getRuleContext(InterfaceListContext.class,0);
+		}
+		public List<EnumItemContext> enumItem() {
+			return getRuleContexts(EnumItemContext.class);
+		}
+		public EnumItemContext enumItem(int i) {
+			return getRuleContext(EnumItemContext.class,i);
+		}
+		public TerminalNode IntType() { return getToken(PhpParser.IntType, 0); }
+		public TerminalNode StringType() { return getToken(PhpParser.StringType, 0); }
+		public EnumDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_enumDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterEnumDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitEnumDeclaration(this);
+		}
+	}
+
+	public final EnumDeclarationContext enumDeclaration() throws RecognitionException {
+		EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 156, RULE_enumDeclaration);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1137);
+			match(Enum_);
+			setState(1138);
+			identifier();
+			setState(1141);
+			_la = _input.LA(1);
+			if (_la==Colon) {
+				{
+				setState(1139);
+				match(Colon);
+				setState(1140);
+				_la = _input.LA(1);
+				if ( !(_la==IntType || _la==StringType) ) {
+				_errHandler.recoverInline(this);
+				} else {
+					consume();
+				}
+				}
+			}
+
+			setState(1145);
+			_la = _input.LA(1);
+			if (_la==Implements) {
+				{
+				setState(1143);
+				match(Implements);
+				setState(1144);
+				interfaceList();
+				}
+			}
+
+			setState(1147);
+			match(OpenCurlyBracket);
+			setState(1151);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AttributeStart) | (1L << Abstract) | (1L << Case))) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (Final - 77)) | (1L << (Function_ - 77)) | (1L << (Private - 77)) | (1L << (Protected - 77)) | (1L << (Public - 77)) | (1L << (Readonly - 77)) | (1L << (Static - 77)) | (1L << (Use - 77)))) != 0)) {
+				{
+				{
+				setState(1148);
+				enumItem();
+				}
+				}
+				setState(1153);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(1154);
+			match(CloseCurlyBracket);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class EnumItemContext extends ParserRuleContext {
+		public TerminalNode Case() { return getToken(PhpParser.Case, 0); }
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public TerminalNode SemiColon() { return getToken(PhpParser.SemiColon, 0); }
+		public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); }
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public FunctionDeclarationContext functionDeclaration() {
+			return getRuleContext(FunctionDeclarationContext.class,0);
+		}
+		public MemberModifiersContext memberModifiers() {
+			return getRuleContext(MemberModifiersContext.class,0);
+		}
+		public TerminalNode Use() { return getToken(PhpParser.Use, 0); }
+		public QualifiedNamespaceNameListContext qualifiedNamespaceNameList() {
+			return getRuleContext(QualifiedNamespaceNameListContext.class,0);
+		}
+		public TraitAdaptationsContext traitAdaptations() {
+			return getRuleContext(TraitAdaptationsContext.class,0);
+		}
+		public EnumItemContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_enumItem; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterEnumItem(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitEnumItem(this);
+		}
+	}
+
+	public final EnumItemContext enumItem() throws RecognitionException {
+		EnumItemContext _localctx = new EnumItemContext(_ctx, getState());
+		enterRule(_localctx, 158, RULE_enumItem);
+		int _la;
+		try {
+			setState(1172);
+			switch (_input.LA(1)) {
+			case Case:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1156);
+				match(Case);
+				setState(1157);
+				identifier();
+				setState(1160);
+				_la = _input.LA(1);
+				if (_la==Eq) {
+					{
+					setState(1158);
+					match(Eq);
+					setState(1159);
+					expression(0);
+					}
+				}
+
+				setState(1162);
+				match(SemiColon);
+				}
+				break;
+			case AttributeStart:
+			case Abstract:
+			case Final:
+			case Function_:
+			case Private:
+			case Protected:
+			case Public:
+			case Readonly:
+			case Static:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1165);
+				_la = _input.LA(1);
+				if (_la==Abstract || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (Final - 77)) | (1L << (Private - 77)) | (1L << (Protected - 77)) | (1L << (Public - 77)) | (1L << (Readonly - 77)) | (1L << (Static - 77)))) != 0)) {
+					{
+					setState(1164);
+					memberModifiers();
+					}
+				}
+
+				setState(1167);
+				functionDeclaration();
+				}
+				break;
+			case Use:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(1168);
+				match(Use);
+				setState(1169);
+				qualifiedNamespaceNameList();
+				setState(1170);
+				traitAdaptations();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ExpressionListContext extends ParserRuleContext {
+		public List<ExpressionContext> expression() {
+			return getRuleContexts(ExpressionContext.class);
+		}
+		public ExpressionContext expression(int i) {
+			return getRuleContext(ExpressionContext.class,i);
+		}
+		public ExpressionListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_expressionList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterExpressionList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitExpressionList(this);
+		}
+	}
+
+	public final ExpressionListContext expressionList() throws RecognitionException {
+		ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState());
+		enterRule(_localctx, 160, RULE_expressionList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1174);
+			expression(0);
+			setState(1179);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==Comma) {
+				{
+				{
+				setState(1175);
+				match(Comma);
+				setState(1176);
+				expression(0);
+				}
+				}
+				setState(1181);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ParenthesesContext extends ParserRuleContext {
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public YieldExpressionContext yieldExpression() {
+			return getRuleContext(YieldExpressionContext.class,0);
+		}
+		public ParenthesesContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_parentheses; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterParentheses(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitParentheses(this);
+		}
+	}
+
+	public final ParenthesesContext parentheses() throws RecognitionException {
+		ParenthesesContext _localctx = new ParenthesesContext(_ctx, getState());
+		enterRule(_localctx, 162, RULE_parentheses);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1182);
+			match(OpenRoundBracket);
+			setState(1185);
+			switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) {
+			case 1:
+				{
+				setState(1183);
+				expression(0);
+				}
+				break;
+			case 2:
+				{
+				setState(1184);
+				yieldExpression();
+				}
+				break;
+			}
+			setState(1187);
+			match(CloseRoundBracket);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ExpressionContext extends ParserRuleContext {
+		public ExpressionContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_expression; }
+	 
+		public ExpressionContext() { }
+		public void copyFrom(ExpressionContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class ChainExpressionContext extends ExpressionContext {
+		public ChainContext chain() {
+			return getRuleContext(ChainContext.class,0);
+		}
+		public ChainExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterChainExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitChainExpression(this);
+		}
+	}
+	public static class SpecialWordExpressionContext extends ExpressionContext {
+		public TerminalNode List() { return getToken(PhpParser.List, 0); }
+		public AssignmentListContext assignmentList() {
+			return getRuleContext(AssignmentListContext.class,0);
+		}
+		public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); }
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public TerminalNode Include() { return getToken(PhpParser.Include, 0); }
+		public TerminalNode IncludeOnce() { return getToken(PhpParser.IncludeOnce, 0); }
+		public TerminalNode Require() { return getToken(PhpParser.Require, 0); }
+		public TerminalNode RequireOnce() { return getToken(PhpParser.RequireOnce, 0); }
+		public TerminalNode Throw() { return getToken(PhpParser.Throw, 0); }
+		public TerminalNode Yield() { return getToken(PhpParser.Yield, 0); }
+		public TerminalNode IsSet() { return getToken(PhpParser.IsSet, 0); }
+		public ChainListContext chainList() {
+			return getRuleContext(ChainListContext.class,0);
+		}
+		public TerminalNode Empty() { return getToken(PhpParser.Empty, 0); }
+		public ChainContext chain() {
+			return getRuleContext(ChainContext.class,0);
+		}
+		public TerminalNode Eval() { return getToken(PhpParser.Eval, 0); }
+		public TerminalNode Exit() { return getToken(PhpParser.Exit, 0); }
+		public ParenthesesContext parentheses() {
+			return getRuleContext(ParenthesesContext.class,0);
+		}
+		public SpecialWordExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterSpecialWordExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitSpecialWordExpression(this);
+		}
+	}
+	public static class ArrayCreationExpressionContext extends ExpressionContext {
+		public ArrayCreationContext arrayCreation() {
+			return getRuleContext(ArrayCreationContext.class,0);
+		}
+		public ArrayCreationExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArrayCreationExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArrayCreationExpression(this);
+		}
+	}
+	public static class BackQuoteStringExpressionContext extends ExpressionContext {
+		public TerminalNode BackQuoteString() { return getToken(PhpParser.BackQuoteString, 0); }
+		public BackQuoteStringExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterBackQuoteStringExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitBackQuoteStringExpression(this);
+		}
+	}
+	public static class MatchExpressionContext extends ExpressionContext {
+		public MatchExprContext matchExpr() {
+			return getRuleContext(MatchExprContext.class,0);
+		}
+		public MatchExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMatchExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMatchExpression(this);
+		}
+	}
+	public static class LogicalExpressionContext extends ExpressionContext {
+		public Token op;
+		public List<ExpressionContext> expression() {
+			return getRuleContexts(ExpressionContext.class);
+		}
+		public ExpressionContext expression(int i) {
+			return getRuleContext(ExpressionContext.class,i);
+		}
+		public TerminalNode LogicalAnd() { return getToken(PhpParser.LogicalAnd, 0); }
+		public TerminalNode LogicalXor() { return getToken(PhpParser.LogicalXor, 0); }
+		public TerminalNode LogicalOr() { return getToken(PhpParser.LogicalOr, 0); }
+		public LogicalExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterLogicalExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitLogicalExpression(this);
+		}
+	}
+	public static class PrintExpressionContext extends ExpressionContext {
+		public TerminalNode Print() { return getToken(PhpParser.Print, 0); }
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public PrintExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterPrintExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitPrintExpression(this);
+		}
+	}
+	public static class AssignmentExpressionContext extends ExpressionContext {
+		public AssignableContext assignable() {
+			return getRuleContext(AssignableContext.class,0);
+		}
+		public AssignmentOperatorContext assignmentOperator() {
+			return getRuleContext(AssignmentOperatorContext.class,0);
+		}
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public AttributesContext attributes() {
+			return getRuleContext(AttributesContext.class,0);
+		}
+		public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); }
+		public ChainContext chain() {
+			return getRuleContext(ChainContext.class,0);
+		}
+		public NewExprContext newExpr() {
+			return getRuleContext(NewExprContext.class,0);
+		}
+		public AssignmentExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAssignmentExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAssignmentExpression(this);
+		}
+	}
+	public static class PostfixIncDecExpressionContext extends ExpressionContext {
+		public ChainContext chain() {
+			return getRuleContext(ChainContext.class,0);
+		}
+		public PostfixIncDecExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterPostfixIncDecExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitPostfixIncDecExpression(this);
+		}
+	}
+	public static class CloneExpressionContext extends ExpressionContext {
+		public TerminalNode Clone() { return getToken(PhpParser.Clone, 0); }
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public CloneExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterCloneExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitCloneExpression(this);
+		}
+	}
+	public static class UnaryOperatorExpressionContext extends ExpressionContext {
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public UnaryOperatorExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterUnaryOperatorExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitUnaryOperatorExpression(this);
+		}
+	}
+	public static class NewExpressionContext extends ExpressionContext {
+		public NewExprContext newExpr() {
+			return getRuleContext(NewExprContext.class,0);
+		}
+		public NewExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterNewExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitNewExpression(this);
+		}
+	}
+	public static class ParenthesisExpressionContext extends ExpressionContext {
+		public ParenthesesContext parentheses() {
+			return getRuleContext(ParenthesesContext.class,0);
+		}
+		public ParenthesisExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterParenthesisExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitParenthesisExpression(this);
+		}
+	}
+	public static class SpaceshipExpressionContext extends ExpressionContext {
+		public Token op;
+		public List<ExpressionContext> expression() {
+			return getRuleContexts(ExpressionContext.class);
+		}
+		public ExpressionContext expression(int i) {
+			return getRuleContext(ExpressionContext.class,i);
+		}
+		public SpaceshipExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterSpaceshipExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitSpaceshipExpression(this);
+		}
+	}
+	public static class ConditionalExpressionContext extends ExpressionContext {
+		public Token op;
+		public List<ExpressionContext> expression() {
+			return getRuleContexts(ExpressionContext.class);
+		}
+		public ExpressionContext expression(int i) {
+			return getRuleContext(ExpressionContext.class,i);
+		}
+		public TerminalNode QuestionMark() { return getToken(PhpParser.QuestionMark, 0); }
+		public ConditionalExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterConditionalExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitConditionalExpression(this);
+		}
+	}
+	public static class NullCoalescingExpressionContext extends ExpressionContext {
+		public Token op;
+		public List<ExpressionContext> expression() {
+			return getRuleContexts(ExpressionContext.class);
+		}
+		public ExpressionContext expression(int i) {
+			return getRuleContext(ExpressionContext.class,i);
+		}
+		public NullCoalescingExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterNullCoalescingExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitNullCoalescingExpression(this);
+		}
+	}
+	public static class ArithmeticExpressionContext extends ExpressionContext {
+		public Token op;
+		public List<ExpressionContext> expression() {
+			return getRuleContexts(ExpressionContext.class);
+		}
+		public ExpressionContext expression(int i) {
+			return getRuleContext(ExpressionContext.class,i);
+		}
+		public TerminalNode Divide() { return getToken(PhpParser.Divide, 0); }
+		public ArithmeticExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArithmeticExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArithmeticExpression(this);
+		}
+	}
+	public static class IndexerExpressionContext extends ExpressionContext {
+		public StringConstantContext stringConstant() {
+			return getRuleContext(StringConstantContext.class,0);
+		}
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public IndexerExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterIndexerExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitIndexerExpression(this);
+		}
+	}
+	public static class ScalarExpressionContext extends ExpressionContext {
+		public ConstantContext constant() {
+			return getRuleContext(ConstantContext.class,0);
+		}
+		public StringContext string() {
+			return getRuleContext(StringContext.class,0);
+		}
+		public TerminalNode Label() { return getToken(PhpParser.Label, 0); }
+		public ScalarExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterScalarExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitScalarExpression(this);
+		}
+	}
+	public static class PrefixIncDecExpressionContext extends ExpressionContext {
+		public ChainContext chain() {
+			return getRuleContext(ChainContext.class,0);
+		}
+		public PrefixIncDecExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterPrefixIncDecExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitPrefixIncDecExpression(this);
+		}
+	}
+	public static class ComparisonExpressionContext extends ExpressionContext {
+		public Token op;
+		public List<ExpressionContext> expression() {
+			return getRuleContexts(ExpressionContext.class);
+		}
+		public ExpressionContext expression(int i) {
+			return getRuleContext(ExpressionContext.class,i);
+		}
+		public TerminalNode Less() { return getToken(PhpParser.Less, 0); }
+		public TerminalNode Greater() { return getToken(PhpParser.Greater, 0); }
+		public TerminalNode IsNotEq() { return getToken(PhpParser.IsNotEq, 0); }
+		public ComparisonExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterComparisonExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitComparisonExpression(this);
+		}
+	}
+	public static class CastExpressionContext extends ExpressionContext {
+		public CastOperationContext castOperation() {
+			return getRuleContext(CastOperationContext.class,0);
+		}
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public CastExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterCastExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitCastExpression(this);
+		}
+	}
+	public static class InstanceOfExpressionContext extends ExpressionContext {
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public TerminalNode InstanceOf() { return getToken(PhpParser.InstanceOf, 0); }
+		public TypeRefContext typeRef() {
+			return getRuleContext(TypeRefContext.class,0);
+		}
+		public InstanceOfExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterInstanceOfExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitInstanceOfExpression(this);
+		}
+	}
+	public static class ArrayDestructExpressionContext extends ExpressionContext {
+		public ArrayDestructuringContext arrayDestructuring() {
+			return getRuleContext(ArrayDestructuringContext.class,0);
+		}
+		public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); }
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public ArrayDestructExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArrayDestructExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArrayDestructExpression(this);
+		}
+	}
+	public static class LambdaFunctionExpressionContext extends ExpressionContext {
+		public LambdaFunctionExprContext lambdaFunctionExpr() {
+			return getRuleContext(LambdaFunctionExprContext.class,0);
+		}
+		public LambdaFunctionExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterLambdaFunctionExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitLambdaFunctionExpression(this);
+		}
+	}
+	public static class BitwiseExpressionContext extends ExpressionContext {
+		public Token op;
+		public List<ExpressionContext> expression() {
+			return getRuleContexts(ExpressionContext.class);
+		}
+		public ExpressionContext expression(int i) {
+			return getRuleContext(ExpressionContext.class,i);
+		}
+		public BitwiseExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterBitwiseExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitBitwiseExpression(this);
+		}
+	}
+
+	public final ExpressionContext expression() throws RecognitionException {
+		return expression(0);
+	}
+
+	private ExpressionContext expression(int _p) throws RecognitionException {
+		ParserRuleContext _parentctx = _ctx;
+		int _parentState = getState();
+		ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
+		ExpressionContext _prevctx = _localctx;
+		int _startState = 164;
+		enterRecursionRule(_localctx, 164, RULE_expression, _p);
+		int _la;
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1279);
+			switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
+			case 1:
+				{
+				_localctx = new CloneExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+
+				setState(1190);
+				match(Clone);
+				setState(1191);
+				expression(48);
+				}
+				break;
+			case 2:
+				{
+				_localctx = new CastExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1192);
+				match(OpenRoundBracket);
+				setState(1193);
+				castOperation();
+				setState(1194);
+				match(CloseRoundBracket);
+				setState(1195);
+				expression(45);
+				}
+				break;
+			case 3:
+				{
+				_localctx = new UnaryOperatorExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1197);
+				_la = _input.LA(1);
+				if ( !(_la==Tilde || _la==SuppressWarnings) ) {
+				_errHandler.recoverInline(this);
+				} else {
+					consume();
+				}
+				setState(1198);
+				expression(44);
+				}
+				break;
+			case 4:
+				{
+				_localctx = new UnaryOperatorExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1199);
+				_la = _input.LA(1);
+				if ( !(((((_la - 200)) & ~0x3f) == 0 && ((1L << (_la - 200)) & ((1L << (Bang - 200)) | (1L << (Plus - 200)) | (1L << (Minus - 200)))) != 0)) ) {
+				_errHandler.recoverInline(this);
+				} else {
+					consume();
+				}
+				setState(1200);
+				expression(43);
+				}
+				break;
+			case 5:
+				{
+				_localctx = new PrintExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1201);
+				match(Print);
+				setState(1202);
+				expression(40);
+				}
+				break;
+			case 6:
+				{
+				_localctx = new SpecialWordExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1203);
+				match(List);
+				setState(1204);
+				match(OpenRoundBracket);
+				setState(1205);
+				assignmentList();
+				setState(1206);
+				match(CloseRoundBracket);
+				setState(1207);
+				match(Eq);
+				setState(1208);
+				expression(31);
+				}
+				break;
+			case 7:
+				{
+				_localctx = new SpecialWordExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1210);
+				_la = _input.LA(1);
+				if ( !(_la==Include || _la==IncludeOnce) ) {
+				_errHandler.recoverInline(this);
+				} else {
+					consume();
+				}
+				setState(1211);
+				expression(26);
+				}
+				break;
+			case 8:
+				{
+				_localctx = new SpecialWordExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1212);
+				_la = _input.LA(1);
+				if ( !(_la==Require || _la==RequireOnce) ) {
+				_errHandler.recoverInline(this);
+				} else {
+					consume();
+				}
+				setState(1213);
+				expression(25);
+				}
+				break;
+			case 9:
+				{
+				_localctx = new SpecialWordExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1214);
+				match(Throw);
+				setState(1215);
+				expression(7);
+				}
+				break;
+			case 10:
+				{
+				_localctx = new ArrayDestructExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1216);
+				arrayDestructuring();
+				setState(1217);
+				match(Eq);
+				setState(1218);
+				expression(6);
+				}
+				break;
+			case 11:
+				{
+				_localctx = new AssignmentExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1220);
+				assignable();
+				setState(1221);
+				assignmentOperator();
+				setState(1223);
+				_la = _input.LA(1);
+				if (_la==AttributeStart) {
+					{
+					setState(1222);
+					attributes();
+					}
+				}
+
+				setState(1225);
+				expression(5);
+				}
+				break;
+			case 12:
+				{
+				_localctx = new NewExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1227);
+				newExpr();
+				}
+				break;
+			case 13:
+				{
+				_localctx = new IndexerExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1228);
+				stringConstant();
+				setState(1229);
+				match(OpenSquareBracket);
+				setState(1230);
+				expression(0);
+				setState(1231);
+				match(CloseSquareBracket);
+				}
+				break;
+			case 14:
+				{
+				_localctx = new PrefixIncDecExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1233);
+				_la = _input.LA(1);
+				if ( !(_la==Inc || _la==Dec) ) {
+				_errHandler.recoverInline(this);
+				} else {
+					consume();
+				}
+				setState(1234);
+				chain();
+				}
+				break;
+			case 15:
+				{
+				_localctx = new PostfixIncDecExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1235);
+				chain();
+				setState(1236);
+				_la = _input.LA(1);
+				if ( !(_la==Inc || _la==Dec) ) {
+				_errHandler.recoverInline(this);
+				} else {
+					consume();
+				}
+				}
+				break;
+			case 16:
+				{
+				_localctx = new ArrayCreationExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1238);
+				arrayCreation();
+				}
+				break;
+			case 17:
+				{
+				_localctx = new ChainExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1239);
+				chain();
+				}
+				break;
+			case 18:
+				{
+				_localctx = new ScalarExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1240);
+				constant();
+				}
+				break;
+			case 19:
+				{
+				_localctx = new ScalarExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1241);
+				string();
+				}
+				break;
+			case 20:
+				{
+				_localctx = new ScalarExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1242);
+				match(Label);
+				}
+				break;
+			case 21:
+				{
+				_localctx = new BackQuoteStringExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1243);
+				match(BackQuoteString);
+				}
+				break;
+			case 22:
+				{
+				_localctx = new ParenthesisExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1244);
+				parentheses();
+				}
+				break;
+			case 23:
+				{
+				_localctx = new SpecialWordExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1245);
+				match(Yield);
+				}
+				break;
+			case 24:
+				{
+				_localctx = new SpecialWordExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1246);
+				match(IsSet);
+				setState(1247);
+				match(OpenRoundBracket);
+				setState(1248);
+				chainList();
+				setState(1249);
+				match(CloseRoundBracket);
+				}
+				break;
+			case 25:
+				{
+				_localctx = new SpecialWordExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1251);
+				match(Empty);
+				setState(1252);
+				match(OpenRoundBracket);
+				setState(1253);
+				chain();
+				setState(1254);
+				match(CloseRoundBracket);
+				}
+				break;
+			case 26:
+				{
+				_localctx = new SpecialWordExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1256);
+				match(Eval);
+				setState(1257);
+				match(OpenRoundBracket);
+				setState(1258);
+				expression(0);
+				setState(1259);
+				match(CloseRoundBracket);
+				}
+				break;
+			case 27:
+				{
+				_localctx = new SpecialWordExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1261);
+				match(Exit);
+				setState(1265);
+				switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) {
+				case 1:
+					{
+					setState(1262);
+					match(OpenRoundBracket);
+					setState(1263);
+					match(CloseRoundBracket);
+					}
+					break;
+				case 2:
+					{
+					setState(1264);
+					parentheses();
+					}
+					break;
+				}
+				}
+				break;
+			case 28:
+				{
+				_localctx = new LambdaFunctionExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1267);
+				lambdaFunctionExpr();
+				}
+				break;
+			case 29:
+				{
+				_localctx = new MatchExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1268);
+				matchExpr();
+				}
+				break;
+			case 30:
+				{
+				_localctx = new AssignmentExpressionContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(1269);
+				assignable();
+				setState(1270);
+				match(Eq);
+				setState(1272);
+				_la = _input.LA(1);
+				if (_la==AttributeStart) {
+					{
+					setState(1271);
+					attributes();
+					}
+				}
+
+				setState(1274);
+				match(Ampersand);
+				setState(1277);
+				switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) {
+				case 1:
+					{
+					setState(1275);
+					chain();
+					}
+					break;
+				case 2:
+					{
+					setState(1276);
+					newExpr();
+					}
+					break;
+				}
+				}
+				break;
+			}
+			_ctx.stop = _input.LT(-1);
+			setState(1341);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,143,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					if ( _parseListeners!=null ) triggerExitRuleEvent();
+					_prevctx = _localctx;
+					{
+					setState(1339);
+					switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
+					case 1:
+						{
+						_localctx = new ArithmeticExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1281);
+						if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)");
+						setState(1282);
+						((ArithmeticExpressionContext)_localctx).op = match(Pow);
+						setState(1283);
+						expression(22);
+						}
+						break;
+					case 2:
+						{
+						_localctx = new ArithmeticExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1284);
+						if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
+						setState(1285);
+						((ArithmeticExpressionContext)_localctx).op = _input.LT(1);
+						_la = _input.LA(1);
+						if ( !(((((_la - 204)) & ~0x3f) == 0 && ((1L << (_la - 204)) & ((1L << (Asterisk - 204)) | (1L << (Percent - 204)) | (1L << (Divide - 204)))) != 0)) ) {
+							((ArithmeticExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
+						} else {
+							consume();
+						}
+						setState(1286);
+						expression(21);
+						}
+						break;
+					case 3:
+						{
+						_localctx = new ArithmeticExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1287);
+						if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)");
+						setState(1288);
+						((ArithmeticExpressionContext)_localctx).op = _input.LT(1);
+						_la = _input.LA(1);
+						if ( !(((((_la - 202)) & ~0x3f) == 0 && ((1L << (_la - 202)) & ((1L << (Plus - 202)) | (1L << (Minus - 202)) | (1L << (Dot - 202)))) != 0)) ) {
+							((ArithmeticExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
+						} else {
+							consume();
+						}
+						setState(1289);
+						expression(20);
+						}
+						break;
+					case 4:
+						{
+						_localctx = new ComparisonExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1290);
+						if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
+						setState(1291);
+						((ComparisonExpressionContext)_localctx).op = _input.LT(1);
+						_la = _input.LA(1);
+						if ( !(_la==ShiftLeft || _la==ShiftRight) ) {
+							((ComparisonExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
+						} else {
+							consume();
+						}
+						setState(1292);
+						expression(19);
+						}
+						break;
+					case 5:
+						{
+						_localctx = new ComparisonExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1293);
+						if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
+						setState(1294);
+						((ComparisonExpressionContext)_localctx).op = _input.LT(1);
+						_la = _input.LA(1);
+						if ( !(((((_la - 171)) & ~0x3f) == 0 && ((1L << (_la - 171)) & ((1L << (IsSmallerOrEqual - 171)) | (1L << (IsGreaterOrEqual - 171)) | (1L << (Less - 171)) | (1L << (Greater - 171)))) != 0)) ) {
+							((ComparisonExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
+						} else {
+							consume();
+						}
+						setState(1295);
+						expression(18);
+						}
+						break;
+					case 6:
+						{
+						_localctx = new ComparisonExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1296);
+						if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
+						setState(1297);
+						((ComparisonExpressionContext)_localctx).op = _input.LT(1);
+						_la = _input.LA(1);
+						if ( !(((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & ((1L << (IsIdentical - 167)) | (1L << (IsNoidentical - 167)) | (1L << (IsEqual - 167)) | (1L << (IsNotEq - 167)))) != 0)) ) {
+							((ComparisonExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
+						} else {
+							consume();
+						}
+						setState(1298);
+						expression(17);
+						}
+						break;
+					case 7:
+						{
+						_localctx = new BitwiseExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1299);
+						if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
+						setState(1300);
+						((BitwiseExpressionContext)_localctx).op = match(Ampersand);
+						setState(1301);
+						expression(16);
+						}
+						break;
+					case 8:
+						{
+						_localctx = new BitwiseExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1302);
+						if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
+						setState(1303);
+						((BitwiseExpressionContext)_localctx).op = match(Caret);
+						setState(1304);
+						expression(15);
+						}
+						break;
+					case 9:
+						{
+						_localctx = new BitwiseExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1305);
+						if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
+						setState(1306);
+						((BitwiseExpressionContext)_localctx).op = match(Pipe);
+						setState(1307);
+						expression(14);
+						}
+						break;
+					case 10:
+						{
+						_localctx = new BitwiseExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1308);
+						if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
+						setState(1309);
+						((BitwiseExpressionContext)_localctx).op = match(BooleanAnd);
+						setState(1310);
+						expression(13);
+						}
+						break;
+					case 11:
+						{
+						_localctx = new BitwiseExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1311);
+						if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
+						setState(1312);
+						((BitwiseExpressionContext)_localctx).op = match(BooleanOr);
+						setState(1313);
+						expression(12);
+						}
+						break;
+					case 12:
+						{
+						_localctx = new ConditionalExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1314);
+						if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
+						setState(1315);
+						((ConditionalExpressionContext)_localctx).op = match(QuestionMark);
+						setState(1317);
+						_la = _input.LA(1);
+						if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) {
+							{
+							setState(1316);
+							expression(0);
+							}
+						}
+
+						setState(1319);
+						match(Colon);
+						setState(1320);
+						expression(11);
+						}
+						break;
+					case 13:
+						{
+						_localctx = new NullCoalescingExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1321);
+						if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
+						setState(1322);
+						((NullCoalescingExpressionContext)_localctx).op = match(NullCoalescing);
+						setState(1323);
+						expression(10);
+						}
+						break;
+					case 14:
+						{
+						_localctx = new SpaceshipExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1324);
+						if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
+						setState(1325);
+						((SpaceshipExpressionContext)_localctx).op = match(Spaceship);
+						setState(1326);
+						expression(9);
+						}
+						break;
+					case 15:
+						{
+						_localctx = new LogicalExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1327);
+						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
+						setState(1328);
+						((LogicalExpressionContext)_localctx).op = match(LogicalAnd);
+						setState(1329);
+						expression(4);
+						}
+						break;
+					case 16:
+						{
+						_localctx = new LogicalExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1330);
+						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
+						setState(1331);
+						((LogicalExpressionContext)_localctx).op = match(LogicalXor);
+						setState(1332);
+						expression(3);
+						}
+						break;
+					case 17:
+						{
+						_localctx = new LogicalExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1333);
+						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
+						setState(1334);
+						((LogicalExpressionContext)_localctx).op = match(LogicalOr);
+						setState(1335);
+						expression(2);
+						}
+						break;
+					case 18:
+						{
+						_localctx = new InstanceOfExpressionContext(new ExpressionContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expression);
+						setState(1336);
+						if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)");
+						setState(1337);
+						match(InstanceOf);
+						setState(1338);
+						typeRef();
+						}
+						break;
+					}
+					} 
+				}
+				setState(1343);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,143,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			unrollRecursionContexts(_parentctx);
+		}
+		return _localctx;
+	}
+
+	public static class AssignableContext extends ParserRuleContext {
+		public ChainContext chain() {
+			return getRuleContext(ChainContext.class,0);
+		}
+		public ArrayCreationContext arrayCreation() {
+			return getRuleContext(ArrayCreationContext.class,0);
+		}
+		public AssignableContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_assignable; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAssignable(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAssignable(this);
+		}
+	}
+
+	public final AssignableContext assignable() throws RecognitionException {
+		AssignableContext _localctx = new AssignableContext(_ctx, getState());
+		enterRule(_localctx, 166, RULE_assignable);
+		try {
+			setState(1346);
+			switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1344);
+				chain();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1345);
+				arrayCreation();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ArrayCreationContext extends ParserRuleContext {
+		public TerminalNode Array() { return getToken(PhpParser.Array, 0); }
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public ArrayItemListContext arrayItemList() {
+			return getRuleContext(ArrayItemListContext.class,0);
+		}
+		public ArrayCreationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_arrayCreation; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArrayCreation(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArrayCreation(this);
+		}
+	}
+
+	public final ArrayCreationContext arrayCreation() throws RecognitionException {
+		ArrayCreationContext _localctx = new ArrayCreationContext(_ctx, getState());
+		enterRule(_localctx, 168, RULE_arrayCreation);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1359);
+			switch (_input.LA(1)) {
+			case Array:
+				{
+				setState(1348);
+				match(Array);
+				setState(1349);
+				match(OpenRoundBracket);
+				setState(1351);
+				_la = _input.LA(1);
+				if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Ampersand - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) {
+					{
+					setState(1350);
+					arrayItemList();
+					}
+				}
+
+				setState(1353);
+				match(CloseRoundBracket);
+				}
+				break;
+			case OpenSquareBracket:
+				{
+				setState(1354);
+				match(OpenSquareBracket);
+				setState(1356);
+				_la = _input.LA(1);
+				if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Ampersand - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) {
+					{
+					setState(1355);
+					arrayItemList();
+					}
+				}
+
+				setState(1358);
+				match(CloseSquareBracket);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+			setState(1365);
+			switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) {
+			case 1:
+				{
+				setState(1361);
+				match(OpenSquareBracket);
+				setState(1362);
+				expression(0);
+				setState(1363);
+				match(CloseSquareBracket);
+				}
+				break;
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ArrayDestructuringContext extends ParserRuleContext {
+		public List<IndexedDestructItemContext> indexedDestructItem() {
+			return getRuleContexts(IndexedDestructItemContext.class);
+		}
+		public IndexedDestructItemContext indexedDestructItem(int i) {
+			return getRuleContext(IndexedDestructItemContext.class,i);
+		}
+		public List<KeyedDestructItemContext> keyedDestructItem() {
+			return getRuleContexts(KeyedDestructItemContext.class);
+		}
+		public KeyedDestructItemContext keyedDestructItem(int i) {
+			return getRuleContext(KeyedDestructItemContext.class,i);
+		}
+		public ArrayDestructuringContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_arrayDestructuring; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArrayDestructuring(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArrayDestructuring(this);
+		}
+	}
+
+	public final ArrayDestructuringContext arrayDestructuring() throws RecognitionException {
+		ArrayDestructuringContext _localctx = new ArrayDestructuringContext(_ctx, getState());
+		enterRule(_localctx, 170, RULE_arrayDestructuring);
+		int _la;
+		try {
+			int _alt;
+			setState(1412);
+			switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1367);
+				match(OpenSquareBracket);
+				setState(1371);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==Comma) {
+					{
+					{
+					setState(1368);
+					match(Comma);
+					}
+					}
+					setState(1373);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(1374);
+				indexedDestructItem();
+				setState(1383);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,151,_ctx);
+				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+					if ( _alt==1 ) {
+						{
+						{
+						setState(1376); 
+						_errHandler.sync(this);
+						_la = _input.LA(1);
+						do {
+							{
+							{
+							setState(1375);
+							match(Comma);
+							}
+							}
+							setState(1378); 
+							_errHandler.sync(this);
+							_la = _input.LA(1);
+						} while ( _la==Comma );
+						setState(1380);
+						indexedDestructItem();
+						}
+						} 
+					}
+					setState(1385);
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,151,_ctx);
+				}
+				setState(1389);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==Comma) {
+					{
+					{
+					setState(1386);
+					match(Comma);
+					}
+					}
+					setState(1391);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(1392);
+				match(CloseSquareBracket);
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1394);
+				match(OpenSquareBracket);
+				setState(1395);
+				keyedDestructItem();
+				setState(1404);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,154,_ctx);
+				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+					if ( _alt==1 ) {
+						{
+						{
+						setState(1397); 
+						_errHandler.sync(this);
+						_la = _input.LA(1);
+						do {
+							{
+							{
+							setState(1396);
+							match(Comma);
+							}
+							}
+							setState(1399); 
+							_errHandler.sync(this);
+							_la = _input.LA(1);
+						} while ( _la==Comma );
+						setState(1401);
+						keyedDestructItem();
+						}
+						} 
+					}
+					setState(1406);
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,154,_ctx);
+				}
+				setState(1408);
+				_la = _input.LA(1);
+				if (_la==Comma) {
+					{
+					setState(1407);
+					match(Comma);
+					}
+				}
+
+				setState(1410);
+				match(CloseSquareBracket);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class IndexedDestructItemContext extends ParserRuleContext {
+		public ChainContext chain() {
+			return getRuleContext(ChainContext.class,0);
+		}
+		public IndexedDestructItemContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_indexedDestructItem; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterIndexedDestructItem(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitIndexedDestructItem(this);
+		}
+	}
+
+	public final IndexedDestructItemContext indexedDestructItem() throws RecognitionException {
+		IndexedDestructItemContext _localctx = new IndexedDestructItemContext(_ctx, getState());
+		enterRule(_localctx, 172, RULE_indexedDestructItem);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1415);
+			_la = _input.LA(1);
+			if (_la==Ampersand) {
+				{
+				setState(1414);
+				match(Ampersand);
+				}
+			}
+
+			setState(1417);
+			chain();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class KeyedDestructItemContext extends ParserRuleContext {
+		public ChainContext chain() {
+			return getRuleContext(ChainContext.class,0);
+		}
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public KeyedDestructItemContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_keyedDestructItem; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterKeyedDestructItem(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitKeyedDestructItem(this);
+		}
+	}
+
+	public final KeyedDestructItemContext keyedDestructItem() throws RecognitionException {
+		KeyedDestructItemContext _localctx = new KeyedDestructItemContext(_ctx, getState());
+		enterRule(_localctx, 174, RULE_keyedDestructItem);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1422);
+			switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) {
+			case 1:
+				{
+				setState(1419);
+				expression(0);
+				setState(1420);
+				match(DoubleArrow);
+				}
+				break;
+			}
+			setState(1425);
+			_la = _input.LA(1);
+			if (_la==Ampersand) {
+				{
+				setState(1424);
+				match(Ampersand);
+				}
+			}
+
+			setState(1427);
+			chain();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class LambdaFunctionExprContext extends ParserRuleContext {
+		public TerminalNode Function_() { return getToken(PhpParser.Function_, 0); }
+		public FormalParameterListContext formalParameterList() {
+			return getRuleContext(FormalParameterListContext.class,0);
+		}
+		public BlockStatementContext blockStatement() {
+			return getRuleContext(BlockStatementContext.class,0);
+		}
+		public TerminalNode Static() { return getToken(PhpParser.Static, 0); }
+		public LambdaFunctionUseVarsContext lambdaFunctionUseVars() {
+			return getRuleContext(LambdaFunctionUseVarsContext.class,0);
+		}
+		public TypeHintContext typeHint() {
+			return getRuleContext(TypeHintContext.class,0);
+		}
+		public TerminalNode LambdaFn() { return getToken(PhpParser.LambdaFn, 0); }
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public LambdaFunctionExprContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_lambdaFunctionExpr; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterLambdaFunctionExpr(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitLambdaFunctionExpr(this);
+		}
+	}
+
+	public final LambdaFunctionExprContext lambdaFunctionExpr() throws RecognitionException {
+		LambdaFunctionExprContext _localctx = new LambdaFunctionExprContext(_ctx, getState());
+		enterRule(_localctx, 176, RULE_lambdaFunctionExpr);
+		int _la;
+		try {
+			setState(1455);
+			switch (_input.LA(1)) {
+			case Function_:
+			case Static:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1430);
+				_la = _input.LA(1);
+				if (_la==Static) {
+					{
+					setState(1429);
+					match(Static);
+					}
+				}
+
+				setState(1432);
+				match(Function_);
+				setState(1434);
+				_la = _input.LA(1);
+				if (_la==Ampersand) {
+					{
+					setState(1433);
+					match(Ampersand);
+					}
+				}
+
+				setState(1436);
+				match(OpenRoundBracket);
+				setState(1437);
+				formalParameterList();
+				setState(1438);
+				match(CloseRoundBracket);
+				setState(1440);
+				_la = _input.LA(1);
+				if (_la==Use) {
+					{
+					setState(1439);
+					lambdaFunctionUseVars();
+					}
+				}
+
+				setState(1444);
+				_la = _input.LA(1);
+				if (_la==Colon) {
+					{
+					setState(1442);
+					match(Colon);
+					setState(1443);
+					typeHint(0);
+					}
+				}
+
+				setState(1446);
+				blockStatement();
+				}
+				break;
+			case LambdaFn:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1448);
+				match(LambdaFn);
+				setState(1449);
+				match(OpenRoundBracket);
+				setState(1450);
+				formalParameterList();
+				setState(1451);
+				match(CloseRoundBracket);
+				setState(1452);
+				match(DoubleArrow);
+				setState(1453);
+				expression(0);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class MatchExprContext extends ParserRuleContext {
+		public TerminalNode Match_() { return getToken(PhpParser.Match_, 0); }
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); }
+		public List<MatchItemContext> matchItem() {
+			return getRuleContexts(MatchItemContext.class);
+		}
+		public MatchItemContext matchItem(int i) {
+			return getRuleContext(MatchItemContext.class,i);
+		}
+		public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); }
+		public MatchExprContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_matchExpr; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMatchExpr(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMatchExpr(this);
+		}
+	}
+
+	public final MatchExprContext matchExpr() throws RecognitionException {
+		MatchExprContext _localctx = new MatchExprContext(_ctx, getState());
+		enterRule(_localctx, 178, RULE_matchExpr);
+		int _la;
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1457);
+			match(Match_);
+			setState(1458);
+			match(OpenRoundBracket);
+			setState(1459);
+			expression(0);
+			setState(1460);
+			match(CloseRoundBracket);
+			setState(1461);
+			match(OpenCurlyBracket);
+			setState(1462);
+			matchItem();
+			setState(1467);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,165,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(1463);
+					match(Comma);
+					setState(1464);
+					matchItem();
+					}
+					} 
+				}
+				setState(1469);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,165,_ctx);
+			}
+			setState(1471);
+			_la = _input.LA(1);
+			if (_la==Comma) {
+				{
+				setState(1470);
+				match(Comma);
+				}
+			}
+
+			setState(1473);
+			match(CloseCurlyBracket);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class MatchItemContext extends ParserRuleContext {
+		public List<ExpressionContext> expression() {
+			return getRuleContexts(ExpressionContext.class);
+		}
+		public ExpressionContext expression(int i) {
+			return getRuleContext(ExpressionContext.class,i);
+		}
+		public MatchItemContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_matchItem; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMatchItem(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMatchItem(this);
+		}
+	}
+
+	public final MatchItemContext matchItem() throws RecognitionException {
+		MatchItemContext _localctx = new MatchItemContext(_ctx, getState());
+		enterRule(_localctx, 180, RULE_matchItem);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1475);
+			expression(0);
+			setState(1480);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==Comma) {
+				{
+				{
+				setState(1476);
+				match(Comma);
+				setState(1477);
+				expression(0);
+				}
+				}
+				setState(1482);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(1483);
+			match(DoubleArrow);
+			setState(1484);
+			expression(0);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class NewExprContext extends ParserRuleContext {
+		public TerminalNode New() { return getToken(PhpParser.New, 0); }
+		public TypeRefContext typeRef() {
+			return getRuleContext(TypeRefContext.class,0);
+		}
+		public ArgumentsContext arguments() {
+			return getRuleContext(ArgumentsContext.class,0);
+		}
+		public NewExprContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_newExpr; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterNewExpr(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitNewExpr(this);
+		}
+	}
+
+	public final NewExprContext newExpr() throws RecognitionException {
+		NewExprContext _localctx = new NewExprContext(_ctx, getState());
+		enterRule(_localctx, 182, RULE_newExpr);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1486);
+			match(New);
+			setState(1487);
+			typeRef();
+			setState(1489);
+			switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) {
+			case 1:
+				{
+				setState(1488);
+				arguments();
+				}
+				break;
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class AssignmentOperatorContext extends ParserRuleContext {
+		public TerminalNode Eq() { return getToken(PhpParser.Eq, 0); }
+		public AssignmentOperatorContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_assignmentOperator; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAssignmentOperator(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAssignmentOperator(this);
+		}
+	}
+
+	public final AssignmentOperatorContext assignmentOperator() throws RecognitionException {
+		AssignmentOperatorContext _localctx = new AssignmentOperatorContext(_ctx, getState());
+		enterRule(_localctx, 184, RULE_assignmentOperator);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1491);
+			_la = _input.LA(1);
+			if ( !(((((_la - 173)) & ~0x3f) == 0 && ((1L << (_la - 173)) & ((1L << (PlusEqual - 173)) | (1L << (MinusEqual - 173)) | (1L << (MulEqual - 173)) | (1L << (PowEqual - 173)) | (1L << (DivEqual - 173)) | (1L << (Concaequal - 173)) | (1L << (ModEqual - 173)) | (1L << (ShiftLeftEqual - 173)) | (1L << (ShiftRightEqual - 173)) | (1L << (AndEqual - 173)) | (1L << (OrEqual - 173)) | (1L << (XorEqual - 173)) | (1L << (NullCoalescingEqual - 173)) | (1L << (Eq - 173)))) != 0)) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class YieldExpressionContext extends ParserRuleContext {
+		public TerminalNode Yield() { return getToken(PhpParser.Yield, 0); }
+		public List<ExpressionContext> expression() {
+			return getRuleContexts(ExpressionContext.class);
+		}
+		public ExpressionContext expression(int i) {
+			return getRuleContext(ExpressionContext.class,i);
+		}
+		public TerminalNode From() { return getToken(PhpParser.From, 0); }
+		public YieldExpressionContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_yieldExpression; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterYieldExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitYieldExpression(this);
+		}
+	}
+
+	public final YieldExpressionContext yieldExpression() throws RecognitionException {
+		YieldExpressionContext _localctx = new YieldExpressionContext(_ctx, getState());
+		enterRule(_localctx, 186, RULE_yieldExpression);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1493);
+			match(Yield);
+			setState(1501);
+			switch ( getInterpreter().adaptivePredict(_input,170,_ctx) ) {
+			case 1:
+				{
+				setState(1494);
+				expression(0);
+				setState(1497);
+				_la = _input.LA(1);
+				if (_la==DoubleArrow) {
+					{
+					setState(1495);
+					match(DoubleArrow);
+					setState(1496);
+					expression(0);
+					}
+				}
+
+				}
+				break;
+			case 2:
+				{
+				setState(1499);
+				match(From);
+				setState(1500);
+				expression(0);
+				}
+				break;
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ArrayItemListContext extends ParserRuleContext {
+		public List<ArrayItemContext> arrayItem() {
+			return getRuleContexts(ArrayItemContext.class);
+		}
+		public ArrayItemContext arrayItem(int i) {
+			return getRuleContext(ArrayItemContext.class,i);
+		}
+		public ArrayItemListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_arrayItemList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArrayItemList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArrayItemList(this);
+		}
+	}
+
+	public final ArrayItemListContext arrayItemList() throws RecognitionException {
+		ArrayItemListContext _localctx = new ArrayItemListContext(_ctx, getState());
+		enterRule(_localctx, 188, RULE_arrayItemList);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1503);
+			arrayItem();
+			setState(1508);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,171,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(1504);
+					match(Comma);
+					setState(1505);
+					arrayItem();
+					}
+					} 
+				}
+				setState(1510);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,171,_ctx);
+			}
+			setState(1512);
+			switch ( getInterpreter().adaptivePredict(_input,172,_ctx) ) {
+			case 1:
+				{
+				setState(1511);
+				match(Comma);
+				}
+				break;
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ArrayItemContext extends ParserRuleContext {
+		public List<ExpressionContext> expression() {
+			return getRuleContexts(ExpressionContext.class);
+		}
+		public ExpressionContext expression(int i) {
+			return getRuleContext(ExpressionContext.class,i);
+		}
+		public ChainContext chain() {
+			return getRuleContext(ChainContext.class,0);
+		}
+		public ArrayItemContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_arrayItem; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArrayItem(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArrayItem(this);
+		}
+	}
+
+	public final ArrayItemContext arrayItem() throws RecognitionException {
+		ArrayItemContext _localctx = new ArrayItemContext(_ctx, getState());
+		enterRule(_localctx, 190, RULE_arrayItem);
+		int _la;
+		try {
+			setState(1526);
+			switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1514);
+				expression(0);
+				setState(1517);
+				_la = _input.LA(1);
+				if (_la==DoubleArrow) {
+					{
+					setState(1515);
+					match(DoubleArrow);
+					setState(1516);
+					expression(0);
+					}
+				}
+
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1522);
+				_la = _input.LA(1);
+				if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) {
+					{
+					setState(1519);
+					expression(0);
+					setState(1520);
+					match(DoubleArrow);
+					}
+				}
+
+				setState(1524);
+				match(Ampersand);
+				setState(1525);
+				chain();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class LambdaFunctionUseVarsContext extends ParserRuleContext {
+		public TerminalNode Use() { return getToken(PhpParser.Use, 0); }
+		public List<LambdaFunctionUseVarContext> lambdaFunctionUseVar() {
+			return getRuleContexts(LambdaFunctionUseVarContext.class);
+		}
+		public LambdaFunctionUseVarContext lambdaFunctionUseVar(int i) {
+			return getRuleContext(LambdaFunctionUseVarContext.class,i);
+		}
+		public LambdaFunctionUseVarsContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_lambdaFunctionUseVars; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterLambdaFunctionUseVars(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitLambdaFunctionUseVars(this);
+		}
+	}
+
+	public final LambdaFunctionUseVarsContext lambdaFunctionUseVars() throws RecognitionException {
+		LambdaFunctionUseVarsContext _localctx = new LambdaFunctionUseVarsContext(_ctx, getState());
+		enterRule(_localctx, 192, RULE_lambdaFunctionUseVars);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1528);
+			match(Use);
+			setState(1529);
+			match(OpenRoundBracket);
+			setState(1530);
+			lambdaFunctionUseVar();
+			setState(1535);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==Comma) {
+				{
+				{
+				setState(1531);
+				match(Comma);
+				setState(1532);
+				lambdaFunctionUseVar();
+				}
+				}
+				setState(1537);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(1538);
+			match(CloseRoundBracket);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class LambdaFunctionUseVarContext extends ParserRuleContext {
+		public TerminalNode VarName() { return getToken(PhpParser.VarName, 0); }
+		public LambdaFunctionUseVarContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_lambdaFunctionUseVar; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterLambdaFunctionUseVar(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitLambdaFunctionUseVar(this);
+		}
+	}
+
+	public final LambdaFunctionUseVarContext lambdaFunctionUseVar() throws RecognitionException {
+		LambdaFunctionUseVarContext _localctx = new LambdaFunctionUseVarContext(_ctx, getState());
+		enterRule(_localctx, 194, RULE_lambdaFunctionUseVar);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1541);
+			_la = _input.LA(1);
+			if (_la==Ampersand) {
+				{
+				setState(1540);
+				match(Ampersand);
+				}
+			}
+
+			setState(1543);
+			match(VarName);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class QualifiedStaticTypeRefContext extends ParserRuleContext {
+		public QualifiedNamespaceNameContext qualifiedNamespaceName() {
+			return getRuleContext(QualifiedNamespaceNameContext.class,0);
+		}
+		public GenericDynamicArgsContext genericDynamicArgs() {
+			return getRuleContext(GenericDynamicArgsContext.class,0);
+		}
+		public TerminalNode Static() { return getToken(PhpParser.Static, 0); }
+		public QualifiedStaticTypeRefContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_qualifiedStaticTypeRef; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterQualifiedStaticTypeRef(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitQualifiedStaticTypeRef(this);
+		}
+	}
+
+	public final QualifiedStaticTypeRefContext qualifiedStaticTypeRef() throws RecognitionException {
+		QualifiedStaticTypeRefContext _localctx = new QualifiedStaticTypeRefContext(_ctx, getState());
+		enterRule(_localctx, 196, RULE_qualifiedStaticTypeRef);
+		try {
+			setState(1550);
+			switch ( getInterpreter().adaptivePredict(_input,179,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1545);
+				qualifiedNamespaceName();
+				setState(1547);
+				switch ( getInterpreter().adaptivePredict(_input,178,_ctx) ) {
+				case 1:
+					{
+					setState(1546);
+					genericDynamicArgs();
+					}
+					break;
+				}
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1549);
+				match(Static);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeRefContext extends ParserRuleContext {
+		public QualifiedNamespaceNameContext qualifiedNamespaceName() {
+			return getRuleContext(QualifiedNamespaceNameContext.class,0);
+		}
+		public IndirectTypeRefContext indirectTypeRef() {
+			return getRuleContext(IndirectTypeRefContext.class,0);
+		}
+		public GenericDynamicArgsContext genericDynamicArgs() {
+			return getRuleContext(GenericDynamicArgsContext.class,0);
+		}
+		public PrimitiveTypeContext primitiveType() {
+			return getRuleContext(PrimitiveTypeContext.class,0);
+		}
+		public TerminalNode Static() { return getToken(PhpParser.Static, 0); }
+		public AnonymousClassContext anonymousClass() {
+			return getRuleContext(AnonymousClassContext.class,0);
+		}
+		public TypeRefContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeRef; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterTypeRef(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitTypeRef(this);
+		}
+	}
+
+	public final TypeRefContext typeRef() throws RecognitionException {
+		TypeRefContext _localctx = new TypeRefContext(_ctx, getState());
+		enterRule(_localctx, 198, RULE_typeRef);
+		try {
+			setState(1562);
+			switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1554);
+				switch ( getInterpreter().adaptivePredict(_input,180,_ctx) ) {
+				case 1:
+					{
+					setState(1552);
+					qualifiedNamespaceName();
+					}
+					break;
+				case 2:
+					{
+					setState(1553);
+					indirectTypeRef();
+					}
+					break;
+				}
+				setState(1557);
+				switch ( getInterpreter().adaptivePredict(_input,181,_ctx) ) {
+				case 1:
+					{
+					setState(1556);
+					genericDynamicArgs();
+					}
+					break;
+				}
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1559);
+				primitiveType();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(1560);
+				match(Static);
+				}
+				break;
+			case 4:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(1561);
+				anonymousClass();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class AnonymousClassContext extends ParserRuleContext {
+		public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); }
+		public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); }
+		public ClassEntryTypeContext classEntryType() {
+			return getRuleContext(ClassEntryTypeContext.class,0);
+		}
+		public TerminalNode Interface() { return getToken(PhpParser.Interface, 0); }
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public AttributesContext attributes() {
+			return getRuleContext(AttributesContext.class,0);
+		}
+		public TerminalNode Private() { return getToken(PhpParser.Private, 0); }
+		public ModifierContext modifier() {
+			return getRuleContext(ModifierContext.class,0);
+		}
+		public TerminalNode Partial() { return getToken(PhpParser.Partial, 0); }
+		public List<ClassStatementContext> classStatement() {
+			return getRuleContexts(ClassStatementContext.class);
+		}
+		public ClassStatementContext classStatement(int i) {
+			return getRuleContext(ClassStatementContext.class,i);
+		}
+		public TypeParameterListInBracketsContext typeParameterListInBrackets() {
+			return getRuleContext(TypeParameterListInBracketsContext.class,0);
+		}
+		public TerminalNode Extends() { return getToken(PhpParser.Extends, 0); }
+		public QualifiedStaticTypeRefContext qualifiedStaticTypeRef() {
+			return getRuleContext(QualifiedStaticTypeRefContext.class,0);
+		}
+		public TerminalNode Implements() { return getToken(PhpParser.Implements, 0); }
+		public InterfaceListContext interfaceList() {
+			return getRuleContext(InterfaceListContext.class,0);
+		}
+		public AnonymousClassContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_anonymousClass; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAnonymousClass(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAnonymousClass(this);
+		}
+	}
+
+	public final AnonymousClassContext anonymousClass() throws RecognitionException {
+		AnonymousClassContext _localctx = new AnonymousClassContext(_ctx, getState());
+		enterRule(_localctx, 200, RULE_anonymousClass);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1565);
+			_la = _input.LA(1);
+			if (_la==AttributeStart) {
+				{
+				setState(1564);
+				attributes();
+				}
+			}
+
+			setState(1568);
+			_la = _input.LA(1);
+			if (_la==Private) {
+				{
+				setState(1567);
+				match(Private);
+				}
+			}
+
+			setState(1571);
+			_la = _input.LA(1);
+			if (_la==Abstract || _la==Final) {
+				{
+				setState(1570);
+				modifier();
+				}
+			}
+
+			setState(1574);
+			_la = _input.LA(1);
+			if (_la==Partial) {
+				{
+				setState(1573);
+				match(Partial);
+				}
+			}
+
+			setState(1597);
+			switch (_input.LA(1)) {
+			case Class:
+			case Trait:
+				{
+				setState(1576);
+				classEntryType();
+				setState(1578);
+				_la = _input.LA(1);
+				if (_la==Lgeneric) {
+					{
+					setState(1577);
+					typeParameterListInBrackets();
+					}
+				}
+
+				setState(1582);
+				_la = _input.LA(1);
+				if (_la==Extends) {
+					{
+					setState(1580);
+					match(Extends);
+					setState(1581);
+					qualifiedStaticTypeRef();
+					}
+				}
+
+				setState(1586);
+				_la = _input.LA(1);
+				if (_la==Implements) {
+					{
+					setState(1584);
+					match(Implements);
+					setState(1585);
+					interfaceList();
+					}
+				}
+
+				}
+				break;
+			case Interface:
+				{
+				setState(1588);
+				match(Interface);
+				setState(1589);
+				identifier();
+				setState(1591);
+				_la = _input.LA(1);
+				if (_la==Lgeneric) {
+					{
+					setState(1590);
+					typeParameterListInBrackets();
+					}
+				}
+
+				setState(1595);
+				_la = _input.LA(1);
+				if (_la==Extends) {
+					{
+					setState(1593);
+					match(Extends);
+					setState(1594);
+					interfaceList();
+					}
+				}
+
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+			setState(1599);
+			match(OpenCurlyBracket);
+			setState(1603);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AttributeStart) | (1L << Abstract) | (1L << Const))) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (Final - 77)) | (1L << (Function_ - 77)) | (1L << (Private - 77)) | (1L << (Protected - 77)) | (1L << (Public - 77)) | (1L << (Readonly - 77)) | (1L << (Static - 77)) | (1L << (Use - 77)) | (1L << (Var - 77)))) != 0)) {
+				{
+				{
+				setState(1600);
+				classStatement();
+				}
+				}
+				setState(1605);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(1606);
+			match(CloseCurlyBracket);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class IndirectTypeRefContext extends ParserRuleContext {
+		public ChainBaseContext chainBase() {
+			return getRuleContext(ChainBaseContext.class,0);
+		}
+		public List<KeyedFieldNameContext> keyedFieldName() {
+			return getRuleContexts(KeyedFieldNameContext.class);
+		}
+		public KeyedFieldNameContext keyedFieldName(int i) {
+			return getRuleContext(KeyedFieldNameContext.class,i);
+		}
+		public IndirectTypeRefContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_indirectTypeRef; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterIndirectTypeRef(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitIndirectTypeRef(this);
+		}
+	}
+
+	public final IndirectTypeRefContext indirectTypeRef() throws RecognitionException {
+		IndirectTypeRefContext _localctx = new IndirectTypeRefContext(_ctx, getState());
+		enterRule(_localctx, 202, RULE_indirectTypeRef);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1608);
+			chainBase();
+			setState(1613);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,194,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(1609);
+					match(ObjectOperator);
+					setState(1610);
+					keyedFieldName();
+					}
+					} 
+				}
+				setState(1615);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,194,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class QualifiedNamespaceNameContext extends ParserRuleContext {
+		public NamespaceNameListContext namespaceNameList() {
+			return getRuleContext(NamespaceNameListContext.class,0);
+		}
+		public TerminalNode Namespace() { return getToken(PhpParser.Namespace, 0); }
+		public QualifiedNamespaceNameContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_qualifiedNamespaceName; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterQualifiedNamespaceName(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitQualifiedNamespaceName(this);
+		}
+	}
+
+	public final QualifiedNamespaceNameContext qualifiedNamespaceName() throws RecognitionException {
+		QualifiedNamespaceNameContext _localctx = new QualifiedNamespaceNameContext(_ctx, getState());
+		enterRule(_localctx, 204, RULE_qualifiedNamespaceName);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1617);
+			switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) {
+			case 1:
+				{
+				setState(1616);
+				match(Namespace);
+				}
+				break;
+			}
+			setState(1620);
+			_la = _input.LA(1);
+			if (_la==NamespaceSeparator) {
+				{
+				setState(1619);
+				match(NamespaceSeparator);
+				}
+			}
+
+			setState(1622);
+			namespaceNameList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class NamespaceNameListContext extends ParserRuleContext {
+		public List<IdentifierContext> identifier() {
+			return getRuleContexts(IdentifierContext.class);
+		}
+		public IdentifierContext identifier(int i) {
+			return getRuleContext(IdentifierContext.class,i);
+		}
+		public NamespaceNameTailContext namespaceNameTail() {
+			return getRuleContext(NamespaceNameTailContext.class,0);
+		}
+		public NamespaceNameListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_namespaceNameList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterNamespaceNameList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitNamespaceNameList(this);
+		}
+	}
+
+	public final NamespaceNameListContext namespaceNameList() throws RecognitionException {
+		NamespaceNameListContext _localctx = new NamespaceNameListContext(_ctx, getState());
+		enterRule(_localctx, 206, RULE_namespaceNameList);
+		try {
+			int _alt;
+			setState(1637);
+			switch ( getInterpreter().adaptivePredict(_input,199,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1624);
+				identifier();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1625);
+				identifier();
+				setState(1630);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,197,_ctx);
+				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+					if ( _alt==1 ) {
+						{
+						{
+						setState(1626);
+						match(NamespaceSeparator);
+						setState(1627);
+						identifier();
+						}
+						} 
+					}
+					setState(1632);
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,197,_ctx);
+				}
+				setState(1635);
+				switch ( getInterpreter().adaptivePredict(_input,198,_ctx) ) {
+				case 1:
+					{
+					setState(1633);
+					match(NamespaceSeparator);
+					setState(1634);
+					namespaceNameTail();
+					}
+					break;
+				}
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class NamespaceNameTailContext extends ParserRuleContext {
+		public List<IdentifierContext> identifier() {
+			return getRuleContexts(IdentifierContext.class);
+		}
+		public IdentifierContext identifier(int i) {
+			return getRuleContext(IdentifierContext.class,i);
+		}
+		public TerminalNode As() { return getToken(PhpParser.As, 0); }
+		public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); }
+		public List<NamespaceNameTailContext> namespaceNameTail() {
+			return getRuleContexts(NamespaceNameTailContext.class);
+		}
+		public NamespaceNameTailContext namespaceNameTail(int i) {
+			return getRuleContext(NamespaceNameTailContext.class,i);
+		}
+		public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); }
+		public NamespaceNameTailContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_namespaceNameTail; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterNamespaceNameTail(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitNamespaceNameTail(this);
+		}
+	}
+
+	public final NamespaceNameTailContext namespaceNameTail() throws RecognitionException {
+		NamespaceNameTailContext _localctx = new NamespaceNameTailContext(_ctx, getState());
+		enterRule(_localctx, 208, RULE_namespaceNameTail);
+		int _la;
+		try {
+			int _alt;
+			setState(1658);
+			switch (_input.LA(1)) {
+			case Abstract:
+			case Array:
+			case As:
+			case BinaryCast:
+			case BoolType:
+			case BooleanConstant:
+			case Break:
+			case Callable:
+			case Case:
+			case Catch:
+			case Class:
+			case Clone:
+			case Const:
+			case Continue:
+			case Declare:
+			case Default:
+			case Do:
+			case DoubleCast:
+			case DoubleType:
+			case Echo:
+			case Else:
+			case ElseIf:
+			case Empty:
+			case Enum_:
+			case EndDeclare:
+			case EndFor:
+			case EndForeach:
+			case EndIf:
+			case EndSwitch:
+			case EndWhile:
+			case Eval:
+			case Exit:
+			case Extends:
+			case Final:
+			case Finally:
+			case FloatCast:
+			case For:
+			case Foreach:
+			case Function_:
+			case Global:
+			case Goto:
+			case If:
+			case Implements:
+			case Import:
+			case Include:
+			case IncludeOnce:
+			case InstanceOf:
+			case InsteadOf:
+			case Int8Cast:
+			case Int16Cast:
+			case Int64Type:
+			case IntType:
+			case Interface:
+			case IsSet:
+			case List:
+			case LogicalAnd:
+			case LogicalOr:
+			case LogicalXor:
+			case Match_:
+			case Namespace:
+			case New:
+			case Null:
+			case ObjectType:
+			case Parent_:
+			case Partial:
+			case Print:
+			case Private:
+			case Protected:
+			case Public:
+			case Readonly:
+			case Require:
+			case RequireOnce:
+			case Resource:
+			case Return:
+			case Static:
+			case StringType:
+			case Switch:
+			case Throw:
+			case Trait:
+			case Try:
+			case Typeof:
+			case UintCast:
+			case UnicodeCast:
+			case Unset:
+			case Use:
+			case Var:
+			case While:
+			case Yield:
+			case From:
+			case LambdaFn:
+			case Ticks:
+			case Encoding:
+			case StrictTypes:
+			case Get:
+			case Set:
+			case Call:
+			case CallStatic:
+			case Constructor:
+			case Destruct:
+			case Wakeup:
+			case Sleep:
+			case Autoload:
+			case IsSet__:
+			case Unset__:
+			case ToString__:
+			case Invoke:
+			case SetState:
+			case Clone__:
+			case DebugInfo:
+			case Namespace__:
+			case Class__:
+			case Traic__:
+			case Function__:
+			case Method__:
+			case Line__:
+			case File__:
+			case Dir__:
+			case Label:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1639);
+				identifier();
+				setState(1642);
+				switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) {
+				case 1:
+					{
+					setState(1640);
+					match(As);
+					setState(1641);
+					identifier();
+					}
+					break;
+				}
+				}
+				break;
+			case OpenCurlyBracket:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1644);
+				match(OpenCurlyBracket);
+				setState(1645);
+				namespaceNameTail();
+				setState(1650);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,201,_ctx);
+				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+					if ( _alt==1 ) {
+						{
+						{
+						setState(1646);
+						match(Comma);
+						setState(1647);
+						namespaceNameTail();
+						}
+						} 
+					}
+					setState(1652);
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,201,_ctx);
+				}
+				setState(1654);
+				_la = _input.LA(1);
+				if (_la==Comma) {
+					{
+					setState(1653);
+					match(Comma);
+					}
+				}
+
+				setState(1656);
+				match(CloseCurlyBracket);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class QualifiedNamespaceNameListContext extends ParserRuleContext {
+		public List<QualifiedNamespaceNameContext> qualifiedNamespaceName() {
+			return getRuleContexts(QualifiedNamespaceNameContext.class);
+		}
+		public QualifiedNamespaceNameContext qualifiedNamespaceName(int i) {
+			return getRuleContext(QualifiedNamespaceNameContext.class,i);
+		}
+		public QualifiedNamespaceNameListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_qualifiedNamespaceNameList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterQualifiedNamespaceNameList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitQualifiedNamespaceNameList(this);
+		}
+	}
+
+	public final QualifiedNamespaceNameListContext qualifiedNamespaceNameList() throws RecognitionException {
+		QualifiedNamespaceNameListContext _localctx = new QualifiedNamespaceNameListContext(_ctx, getState());
+		enterRule(_localctx, 210, RULE_qualifiedNamespaceNameList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1660);
+			qualifiedNamespaceName();
+			setState(1665);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==Comma) {
+				{
+				{
+				setState(1661);
+				match(Comma);
+				setState(1662);
+				qualifiedNamespaceName();
+				}
+				}
+				setState(1667);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ArgumentsContext extends ParserRuleContext {
+		public List<ActualArgumentContext> actualArgument() {
+			return getRuleContexts(ActualArgumentContext.class);
+		}
+		public ActualArgumentContext actualArgument(int i) {
+			return getRuleContext(ActualArgumentContext.class,i);
+		}
+		public YieldExpressionContext yieldExpression() {
+			return getRuleContext(YieldExpressionContext.class,0);
+		}
+		public ArgumentsContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_arguments; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArguments(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArguments(this);
+		}
+	}
+
+	public final ArgumentsContext arguments() throws RecognitionException {
+		ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState());
+		enterRule(_localctx, 212, RULE_arguments);
+		int _la;
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1668);
+			match(OpenRoundBracket);
+			setState(1678);
+			switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) {
+			case 1:
+				{
+				setState(1669);
+				actualArgument();
+				setState(1674);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,205,_ctx);
+				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+					if ( _alt==1 ) {
+						{
+						{
+						setState(1670);
+						match(Comma);
+						setState(1671);
+						actualArgument();
+						}
+						} 
+					}
+					setState(1676);
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,205,_ctx);
+				}
+				}
+				break;
+			case 2:
+				{
+				setState(1677);
+				yieldExpression();
+				}
+				break;
+			}
+			setState(1681);
+			_la = _input.LA(1);
+			if (_la==Comma) {
+				{
+				setState(1680);
+				match(Comma);
+				}
+			}
+
+			setState(1683);
+			match(CloseRoundBracket);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ActualArgumentContext extends ParserRuleContext {
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public ArgumentNameContext argumentName() {
+			return getRuleContext(ArgumentNameContext.class,0);
+		}
+		public ChainContext chain() {
+			return getRuleContext(ChainContext.class,0);
+		}
+		public ActualArgumentContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_actualArgument; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterActualArgument(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitActualArgument(this);
+		}
+	}
+
+	public final ActualArgumentContext actualArgument() throws RecognitionException {
+		ActualArgumentContext _localctx = new ActualArgumentContext(_ctx, getState());
+		enterRule(_localctx, 214, RULE_actualArgument);
+		int _la;
+		try {
+			setState(1694);
+			switch (_input.LA(1)) {
+			case Abstract:
+			case Array:
+			case As:
+			case BinaryCast:
+			case BoolType:
+			case BooleanConstant:
+			case Break:
+			case Callable:
+			case Case:
+			case Catch:
+			case Class:
+			case Clone:
+			case Const:
+			case Continue:
+			case Declare:
+			case Default:
+			case Do:
+			case DoubleCast:
+			case DoubleType:
+			case Echo:
+			case Else:
+			case ElseIf:
+			case Empty:
+			case Enum_:
+			case EndDeclare:
+			case EndFor:
+			case EndForeach:
+			case EndIf:
+			case EndSwitch:
+			case EndWhile:
+			case Eval:
+			case Exit:
+			case Extends:
+			case Final:
+			case Finally:
+			case FloatCast:
+			case For:
+			case Foreach:
+			case Function_:
+			case Global:
+			case Goto:
+			case If:
+			case Implements:
+			case Import:
+			case Include:
+			case IncludeOnce:
+			case InstanceOf:
+			case InsteadOf:
+			case Int8Cast:
+			case Int16Cast:
+			case Int64Type:
+			case IntType:
+			case Interface:
+			case IsSet:
+			case List:
+			case LogicalAnd:
+			case LogicalOr:
+			case LogicalXor:
+			case Match_:
+			case Namespace:
+			case New:
+			case Null:
+			case ObjectType:
+			case Parent_:
+			case Partial:
+			case Print:
+			case Private:
+			case Protected:
+			case Public:
+			case Readonly:
+			case Require:
+			case RequireOnce:
+			case Resource:
+			case Return:
+			case Static:
+			case StringType:
+			case Switch:
+			case Throw:
+			case Trait:
+			case Try:
+			case Typeof:
+			case UintCast:
+			case UnicodeCast:
+			case Unset:
+			case Use:
+			case Var:
+			case While:
+			case Yield:
+			case From:
+			case LambdaFn:
+			case Ticks:
+			case Encoding:
+			case StrictTypes:
+			case Get:
+			case Set:
+			case Call:
+			case CallStatic:
+			case Constructor:
+			case Destruct:
+			case Wakeup:
+			case Sleep:
+			case Autoload:
+			case IsSet__:
+			case Unset__:
+			case ToString__:
+			case Invoke:
+			case SetState:
+			case Clone__:
+			case DebugInfo:
+			case Namespace__:
+			case Class__:
+			case Traic__:
+			case Function__:
+			case Method__:
+			case Line__:
+			case File__:
+			case Dir__:
+			case Inc:
+			case Dec:
+			case NamespaceSeparator:
+			case Ellipsis:
+			case Bang:
+			case Plus:
+			case Minus:
+			case Tilde:
+			case SuppressWarnings:
+			case Dollar:
+			case OpenRoundBracket:
+			case OpenSquareBracket:
+			case VarName:
+			case Label:
+			case Octal:
+			case Decimal:
+			case Real:
+			case Hex:
+			case Binary:
+			case BackQuoteString:
+			case SingleQuoteString:
+			case DoubleQuote:
+			case StartNowDoc:
+			case StartHereDoc:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1686);
+				switch ( getInterpreter().adaptivePredict(_input,208,_ctx) ) {
+				case 1:
+					{
+					setState(1685);
+					argumentName();
+					}
+					break;
+				}
+				setState(1689);
+				_la = _input.LA(1);
+				if (_la==Ellipsis) {
+					{
+					setState(1688);
+					match(Ellipsis);
+					}
+				}
+
+				setState(1691);
+				expression(0);
+				}
+				break;
+			case Ampersand:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1692);
+				match(Ampersand);
+				setState(1693);
+				chain();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ArgumentNameContext extends ParserRuleContext {
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public ArgumentNameContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_argumentName; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterArgumentName(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitArgumentName(this);
+		}
+	}
+
+	public final ArgumentNameContext argumentName() throws RecognitionException {
+		ArgumentNameContext _localctx = new ArgumentNameContext(_ctx, getState());
+		enterRule(_localctx, 216, RULE_argumentName);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1696);
+			identifier();
+			setState(1697);
+			match(Colon);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ConstantInitializerContext extends ParserRuleContext {
+		public List<ConstantContext> constant() {
+			return getRuleContexts(ConstantContext.class);
+		}
+		public ConstantContext constant(int i) {
+			return getRuleContext(ConstantContext.class,i);
+		}
+		public List<StringContext> string() {
+			return getRuleContexts(StringContext.class);
+		}
+		public StringContext string(int i) {
+			return getRuleContext(StringContext.class,i);
+		}
+		public TerminalNode Array() { return getToken(PhpParser.Array, 0); }
+		public ArrayItemListContext arrayItemList() {
+			return getRuleContext(ArrayItemListContext.class,0);
+		}
+		public ConstantInitializerContext constantInitializer() {
+			return getRuleContext(ConstantInitializerContext.class,0);
+		}
+		public ConstantInitializerContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_constantInitializer; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterConstantInitializer(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitConstantInitializer(this);
+		}
+	}
+
+	public final ConstantInitializerContext constantInitializer() throws RecognitionException {
+		ConstantInitializerContext _localctx = new ConstantInitializerContext(_ctx, getState());
+		enterRule(_localctx, 218, RULE_constantInitializer);
+		int _la;
+		try {
+			setState(1734);
+			switch ( getInterpreter().adaptivePredict(_input,218,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1699);
+				constant();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1700);
+				string();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(1701);
+				match(Array);
+				setState(1702);
+				match(OpenRoundBracket);
+				setState(1707);
+				_la = _input.LA(1);
+				if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Ampersand - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) {
+					{
+					setState(1703);
+					arrayItemList();
+					setState(1705);
+					_la = _input.LA(1);
+					if (_la==Comma) {
+						{
+						setState(1704);
+						match(Comma);
+						}
+					}
+
+					}
+				}
+
+				setState(1709);
+				match(CloseRoundBracket);
+				}
+				break;
+			case 4:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(1710);
+				match(OpenSquareBracket);
+				setState(1715);
+				_la = _input.LA(1);
+				if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Ampersand - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) {
+					{
+					setState(1711);
+					arrayItemList();
+					setState(1713);
+					_la = _input.LA(1);
+					if (_la==Comma) {
+						{
+						setState(1712);
+						match(Comma);
+						}
+					}
+
+					}
+				}
+
+				setState(1717);
+				match(CloseSquareBracket);
+				}
+				break;
+			case 5:
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(1718);
+				_la = _input.LA(1);
+				if ( !(_la==Plus || _la==Minus) ) {
+				_errHandler.recoverInline(this);
+				} else {
+					consume();
+				}
+				setState(1719);
+				constantInitializer();
+				}
+				break;
+			case 6:
+				enterOuterAlt(_localctx, 6);
+				{
+				setState(1722);
+				switch ( getInterpreter().adaptivePredict(_input,215,_ctx) ) {
+				case 1:
+					{
+					setState(1720);
+					string();
+					}
+					break;
+				case 2:
+					{
+					setState(1721);
+					constant();
+					}
+					break;
+				}
+				setState(1731);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==Dot) {
+					{
+					{
+					setState(1724);
+					match(Dot);
+					setState(1727);
+					switch ( getInterpreter().adaptivePredict(_input,216,_ctx) ) {
+					case 1:
+						{
+						setState(1725);
+						string();
+						}
+						break;
+					case 2:
+						{
+						setState(1726);
+						constant();
+						}
+						break;
+					}
+					}
+					}
+					setState(1733);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ConstantContext extends ParserRuleContext {
+		public TerminalNode Null() { return getToken(PhpParser.Null, 0); }
+		public LiteralConstantContext literalConstant() {
+			return getRuleContext(LiteralConstantContext.class,0);
+		}
+		public MagicConstantContext magicConstant() {
+			return getRuleContext(MagicConstantContext.class,0);
+		}
+		public ClassConstantContext classConstant() {
+			return getRuleContext(ClassConstantContext.class,0);
+		}
+		public QualifiedNamespaceNameContext qualifiedNamespaceName() {
+			return getRuleContext(QualifiedNamespaceNameContext.class,0);
+		}
+		public ConstantContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_constant; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterConstant(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitConstant(this);
+		}
+	}
+
+	public final ConstantContext constant() throws RecognitionException {
+		ConstantContext _localctx = new ConstantContext(_ctx, getState());
+		enterRule(_localctx, 220, RULE_constant);
+		try {
+			setState(1741);
+			switch ( getInterpreter().adaptivePredict(_input,219,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1736);
+				match(Null);
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1737);
+				literalConstant();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(1738);
+				magicConstant();
+				}
+				break;
+			case 4:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(1739);
+				classConstant();
+				}
+				break;
+			case 5:
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(1740);
+				qualifiedNamespaceName();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class LiteralConstantContext extends ParserRuleContext {
+		public TerminalNode Real() { return getToken(PhpParser.Real, 0); }
+		public TerminalNode BooleanConstant() { return getToken(PhpParser.BooleanConstant, 0); }
+		public NumericConstantContext numericConstant() {
+			return getRuleContext(NumericConstantContext.class,0);
+		}
+		public StringConstantContext stringConstant() {
+			return getRuleContext(StringConstantContext.class,0);
+		}
+		public LiteralConstantContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_literalConstant; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterLiteralConstant(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitLiteralConstant(this);
+		}
+	}
+
+	public final LiteralConstantContext literalConstant() throws RecognitionException {
+		LiteralConstantContext _localctx = new LiteralConstantContext(_ctx, getState());
+		enterRule(_localctx, 222, RULE_literalConstant);
+		try {
+			setState(1747);
+			switch (_input.LA(1)) {
+			case Real:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1743);
+				match(Real);
+				}
+				break;
+			case BooleanConstant:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1744);
+				match(BooleanConstant);
+				}
+				break;
+			case Octal:
+			case Decimal:
+			case Hex:
+			case Binary:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(1745);
+				numericConstant();
+				}
+				break;
+			case Label:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(1746);
+				stringConstant();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class NumericConstantContext extends ParserRuleContext {
+		public TerminalNode Octal() { return getToken(PhpParser.Octal, 0); }
+		public TerminalNode Decimal() { return getToken(PhpParser.Decimal, 0); }
+		public TerminalNode Hex() { return getToken(PhpParser.Hex, 0); }
+		public TerminalNode Binary() { return getToken(PhpParser.Binary, 0); }
+		public NumericConstantContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_numericConstant; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterNumericConstant(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitNumericConstant(this);
+		}
+	}
+
+	public final NumericConstantContext numericConstant() throws RecognitionException {
+		NumericConstantContext _localctx = new NumericConstantContext(_ctx, getState());
+		enterRule(_localctx, 224, RULE_numericConstant);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1749);
+			_la = _input.LA(1);
+			if ( !(((((_la - 226)) & ~0x3f) == 0 && ((1L << (_la - 226)) & ((1L << (Octal - 226)) | (1L << (Decimal - 226)) | (1L << (Hex - 226)) | (1L << (Binary - 226)))) != 0)) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ClassConstantContext extends ParserRuleContext {
+		public TerminalNode Class() { return getToken(PhpParser.Class, 0); }
+		public TerminalNode Parent_() { return getToken(PhpParser.Parent_, 0); }
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public TerminalNode Constructor() { return getToken(PhpParser.Constructor, 0); }
+		public TerminalNode Get() { return getToken(PhpParser.Get, 0); }
+		public TerminalNode Set() { return getToken(PhpParser.Set, 0); }
+		public QualifiedStaticTypeRefContext qualifiedStaticTypeRef() {
+			return getRuleContext(QualifiedStaticTypeRefContext.class,0);
+		}
+		public List<KeyedVariableContext> keyedVariable() {
+			return getRuleContexts(KeyedVariableContext.class);
+		}
+		public KeyedVariableContext keyedVariable(int i) {
+			return getRuleContext(KeyedVariableContext.class,i);
+		}
+		public StringContext string() {
+			return getRuleContext(StringContext.class,0);
+		}
+		public ClassConstantContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_classConstant; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterClassConstant(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitClassConstant(this);
+		}
+	}
+
+	public final ClassConstantContext classConstant() throws RecognitionException {
+		ClassConstantContext _localctx = new ClassConstantContext(_ctx, getState());
+		enterRule(_localctx, 226, RULE_classConstant);
+		int _la;
+		try {
+			setState(1769);
+			switch ( getInterpreter().adaptivePredict(_input,224,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1751);
+				_la = _input.LA(1);
+				if ( !(_la==Class || _la==Parent_) ) {
+				_errHandler.recoverInline(this);
+				} else {
+					consume();
+				}
+				setState(1752);
+				match(DoubleColon);
+				setState(1757);
+				switch ( getInterpreter().adaptivePredict(_input,221,_ctx) ) {
+				case 1:
+					{
+					setState(1753);
+					identifier();
+					}
+					break;
+				case 2:
+					{
+					setState(1754);
+					match(Constructor);
+					}
+					break;
+				case 3:
+					{
+					setState(1755);
+					match(Get);
+					}
+					break;
+				case 4:
+					{
+					setState(1756);
+					match(Set);
+					}
+					break;
+				}
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1762);
+				switch (_input.LA(1)) {
+				case Abstract:
+				case Array:
+				case As:
+				case BinaryCast:
+				case BoolType:
+				case BooleanConstant:
+				case Break:
+				case Callable:
+				case Case:
+				case Catch:
+				case Class:
+				case Clone:
+				case Const:
+				case Continue:
+				case Declare:
+				case Default:
+				case Do:
+				case DoubleCast:
+				case DoubleType:
+				case Echo:
+				case Else:
+				case ElseIf:
+				case Empty:
+				case Enum_:
+				case EndDeclare:
+				case EndFor:
+				case EndForeach:
+				case EndIf:
+				case EndSwitch:
+				case EndWhile:
+				case Eval:
+				case Exit:
+				case Extends:
+				case Final:
+				case Finally:
+				case FloatCast:
+				case For:
+				case Foreach:
+				case Function_:
+				case Global:
+				case Goto:
+				case If:
+				case Implements:
+				case Import:
+				case Include:
+				case IncludeOnce:
+				case InstanceOf:
+				case InsteadOf:
+				case Int8Cast:
+				case Int16Cast:
+				case Int64Type:
+				case IntType:
+				case Interface:
+				case IsSet:
+				case List:
+				case LogicalAnd:
+				case LogicalOr:
+				case LogicalXor:
+				case Match_:
+				case Namespace:
+				case New:
+				case Null:
+				case ObjectType:
+				case Parent_:
+				case Partial:
+				case Print:
+				case Private:
+				case Protected:
+				case Public:
+				case Readonly:
+				case Require:
+				case RequireOnce:
+				case Resource:
+				case Return:
+				case Static:
+				case StringType:
+				case Switch:
+				case Throw:
+				case Trait:
+				case Try:
+				case Typeof:
+				case UintCast:
+				case UnicodeCast:
+				case Unset:
+				case Use:
+				case Var:
+				case While:
+				case Yield:
+				case From:
+				case LambdaFn:
+				case Ticks:
+				case Encoding:
+				case StrictTypes:
+				case Get:
+				case Set:
+				case Call:
+				case CallStatic:
+				case Constructor:
+				case Destruct:
+				case Wakeup:
+				case Sleep:
+				case Autoload:
+				case IsSet__:
+				case Unset__:
+				case ToString__:
+				case Invoke:
+				case SetState:
+				case Clone__:
+				case DebugInfo:
+				case Namespace__:
+				case Class__:
+				case Traic__:
+				case Function__:
+				case Method__:
+				case Line__:
+				case File__:
+				case Dir__:
+				case NamespaceSeparator:
+				case Label:
+					{
+					setState(1759);
+					qualifiedStaticTypeRef();
+					}
+					break;
+				case Dollar:
+				case VarName:
+					{
+					setState(1760);
+					keyedVariable();
+					}
+					break;
+				case SingleQuoteString:
+				case DoubleQuote:
+				case StartNowDoc:
+				case StartHereDoc:
+					{
+					setState(1761);
+					string();
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				setState(1764);
+				match(DoubleColon);
+				setState(1767);
+				switch (_input.LA(1)) {
+				case Abstract:
+				case Array:
+				case As:
+				case BinaryCast:
+				case BoolType:
+				case BooleanConstant:
+				case Break:
+				case Callable:
+				case Case:
+				case Catch:
+				case Class:
+				case Clone:
+				case Const:
+				case Continue:
+				case Declare:
+				case Default:
+				case Do:
+				case DoubleCast:
+				case DoubleType:
+				case Echo:
+				case Else:
+				case ElseIf:
+				case Empty:
+				case Enum_:
+				case EndDeclare:
+				case EndFor:
+				case EndForeach:
+				case EndIf:
+				case EndSwitch:
+				case EndWhile:
+				case Eval:
+				case Exit:
+				case Extends:
+				case Final:
+				case Finally:
+				case FloatCast:
+				case For:
+				case Foreach:
+				case Function_:
+				case Global:
+				case Goto:
+				case If:
+				case Implements:
+				case Import:
+				case Include:
+				case IncludeOnce:
+				case InstanceOf:
+				case InsteadOf:
+				case Int8Cast:
+				case Int16Cast:
+				case Int64Type:
+				case IntType:
+				case Interface:
+				case IsSet:
+				case List:
+				case LogicalAnd:
+				case LogicalOr:
+				case LogicalXor:
+				case Match_:
+				case Namespace:
+				case New:
+				case Null:
+				case ObjectType:
+				case Parent_:
+				case Partial:
+				case Print:
+				case Private:
+				case Protected:
+				case Public:
+				case Readonly:
+				case Require:
+				case RequireOnce:
+				case Resource:
+				case Return:
+				case Static:
+				case StringType:
+				case Switch:
+				case Throw:
+				case Trait:
+				case Try:
+				case Typeof:
+				case UintCast:
+				case UnicodeCast:
+				case Unset:
+				case Use:
+				case Var:
+				case While:
+				case Yield:
+				case From:
+				case LambdaFn:
+				case Ticks:
+				case Encoding:
+				case StrictTypes:
+				case Get:
+				case Set:
+				case Call:
+				case CallStatic:
+				case Constructor:
+				case Destruct:
+				case Wakeup:
+				case Sleep:
+				case Autoload:
+				case IsSet__:
+				case Unset__:
+				case ToString__:
+				case Invoke:
+				case SetState:
+				case Clone__:
+				case DebugInfo:
+				case Namespace__:
+				case Class__:
+				case Traic__:
+				case Function__:
+				case Method__:
+				case Line__:
+				case File__:
+				case Dir__:
+				case Label:
+					{
+					setState(1765);
+					identifier();
+					}
+					break;
+				case Dollar:
+				case VarName:
+					{
+					setState(1766);
+					keyedVariable();
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class StringConstantContext extends ParserRuleContext {
+		public TerminalNode Label() { return getToken(PhpParser.Label, 0); }
+		public StringConstantContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_stringConstant; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterStringConstant(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitStringConstant(this);
+		}
+	}
+
+	public final StringConstantContext stringConstant() throws RecognitionException {
+		StringConstantContext _localctx = new StringConstantContext(_ctx, getState());
+		enterRule(_localctx, 228, RULE_stringConstant);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1771);
+			match(Label);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class StringContext extends ParserRuleContext {
+		public TerminalNode StartHereDoc() { return getToken(PhpParser.StartHereDoc, 0); }
+		public List<TerminalNode> HereDocText() { return getTokens(PhpParser.HereDocText); }
+		public TerminalNode HereDocText(int i) {
+			return getToken(PhpParser.HereDocText, i);
+		}
+		public TerminalNode StartNowDoc() { return getToken(PhpParser.StartNowDoc, 0); }
+		public TerminalNode SingleQuoteString() { return getToken(PhpParser.SingleQuoteString, 0); }
+		public List<TerminalNode> DoubleQuote() { return getTokens(PhpParser.DoubleQuote); }
+		public TerminalNode DoubleQuote(int i) {
+			return getToken(PhpParser.DoubleQuote, i);
+		}
+		public List<InterpolatedStringPartContext> interpolatedStringPart() {
+			return getRuleContexts(InterpolatedStringPartContext.class);
+		}
+		public InterpolatedStringPartContext interpolatedStringPart(int i) {
+			return getRuleContext(InterpolatedStringPartContext.class,i);
+		}
+		public StringContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_string; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterString(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitString(this);
+		}
+	}
+
+	public final StringContext string() throws RecognitionException {
+		StringContext _localctx = new StringContext(_ctx, getState());
+		enterRule(_localctx, 230, RULE_string);
+		try {
+			int _alt;
+			setState(1794);
+			switch (_input.LA(1)) {
+			case StartHereDoc:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1773);
+				match(StartHereDoc);
+				setState(1775); 
+				_errHandler.sync(this);
+				_alt = 1;
+				do {
+					switch (_alt) {
+					case 1:
+						{
+						{
+						setState(1774);
+						match(HereDocText);
+						}
+						}
+						break;
+					default:
+						throw new NoViableAltException(this);
+					}
+					setState(1777); 
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,225,_ctx);
+				} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+				}
+				break;
+			case StartNowDoc:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1779);
+				match(StartNowDoc);
+				setState(1781); 
+				_errHandler.sync(this);
+				_alt = 1;
+				do {
+					switch (_alt) {
+					case 1:
+						{
+						{
+						setState(1780);
+						match(HereDocText);
+						}
+						}
+						break;
+					default:
+						throw new NoViableAltException(this);
+					}
+					setState(1783); 
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,226,_ctx);
+				} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+				}
+				break;
+			case SingleQuoteString:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(1785);
+				match(SingleQuoteString);
+				}
+				break;
+			case DoubleQuote:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(1786);
+				match(DoubleQuote);
+				setState(1790);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,227,_ctx);
+				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+					if ( _alt==1 ) {
+						{
+						{
+						setState(1787);
+						interpolatedStringPart();
+						}
+						} 
+					}
+					setState(1792);
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,227,_ctx);
+				}
+				setState(1793);
+				match(DoubleQuote);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InterpolatedStringPartContext extends ParserRuleContext {
+		public TerminalNode StringPart() { return getToken(PhpParser.StringPart, 0); }
+		public TerminalNode UnicodeEscape() { return getToken(PhpParser.UnicodeEscape, 0); }
+		public ChainContext chain() {
+			return getRuleContext(ChainContext.class,0);
+		}
+		public InterpolatedStringPartContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_interpolatedStringPart; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterInterpolatedStringPart(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitInterpolatedStringPart(this);
+		}
+	}
+
+	public final InterpolatedStringPartContext interpolatedStringPart() throws RecognitionException {
+		InterpolatedStringPartContext _localctx = new InterpolatedStringPartContext(_ctx, getState());
+		enterRule(_localctx, 232, RULE_interpolatedStringPart);
+		try {
+			setState(1799);
+			switch (_input.LA(1)) {
+			case StringPart:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1796);
+				match(StringPart);
+				}
+				break;
+			case UnicodeEscape:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1797);
+				match(UnicodeEscape);
+				}
+				break;
+			case Abstract:
+			case Array:
+			case As:
+			case BinaryCast:
+			case BoolType:
+			case BooleanConstant:
+			case Break:
+			case Callable:
+			case Case:
+			case Catch:
+			case Class:
+			case Clone:
+			case Const:
+			case Continue:
+			case Declare:
+			case Default:
+			case Do:
+			case DoubleCast:
+			case DoubleType:
+			case Echo:
+			case Else:
+			case ElseIf:
+			case Empty:
+			case Enum_:
+			case EndDeclare:
+			case EndFor:
+			case EndForeach:
+			case EndIf:
+			case EndSwitch:
+			case EndWhile:
+			case Eval:
+			case Exit:
+			case Extends:
+			case Final:
+			case Finally:
+			case FloatCast:
+			case For:
+			case Foreach:
+			case Function_:
+			case Global:
+			case Goto:
+			case If:
+			case Implements:
+			case Import:
+			case Include:
+			case IncludeOnce:
+			case InstanceOf:
+			case InsteadOf:
+			case Int8Cast:
+			case Int16Cast:
+			case Int64Type:
+			case IntType:
+			case Interface:
+			case IsSet:
+			case List:
+			case LogicalAnd:
+			case LogicalOr:
+			case LogicalXor:
+			case Match_:
+			case Namespace:
+			case New:
+			case Null:
+			case ObjectType:
+			case Parent_:
+			case Partial:
+			case Print:
+			case Private:
+			case Protected:
+			case Public:
+			case Readonly:
+			case Require:
+			case RequireOnce:
+			case Resource:
+			case Return:
+			case Static:
+			case StringType:
+			case Switch:
+			case Throw:
+			case Trait:
+			case Try:
+			case Typeof:
+			case UintCast:
+			case UnicodeCast:
+			case Unset:
+			case Use:
+			case Var:
+			case While:
+			case Yield:
+			case From:
+			case LambdaFn:
+			case Ticks:
+			case Encoding:
+			case StrictTypes:
+			case Get:
+			case Set:
+			case Call:
+			case CallStatic:
+			case Constructor:
+			case Destruct:
+			case Wakeup:
+			case Sleep:
+			case Autoload:
+			case IsSet__:
+			case Unset__:
+			case ToString__:
+			case Invoke:
+			case SetState:
+			case Clone__:
+			case DebugInfo:
+			case Namespace__:
+			case Class__:
+			case Traic__:
+			case Function__:
+			case Method__:
+			case Line__:
+			case File__:
+			case Dir__:
+			case NamespaceSeparator:
+			case Dollar:
+			case OpenRoundBracket:
+			case VarName:
+			case Label:
+			case SingleQuoteString:
+			case DoubleQuote:
+			case StartNowDoc:
+			case StartHereDoc:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(1798);
+				chain();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ChainListContext extends ParserRuleContext {
+		public List<ChainContext> chain() {
+			return getRuleContexts(ChainContext.class);
+		}
+		public ChainContext chain(int i) {
+			return getRuleContext(ChainContext.class,i);
+		}
+		public ChainListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_chainList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterChainList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitChainList(this);
+		}
+	}
+
+	public final ChainListContext chainList() throws RecognitionException {
+		ChainListContext _localctx = new ChainListContext(_ctx, getState());
+		enterRule(_localctx, 234, RULE_chainList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1801);
+			chain();
+			setState(1806);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==Comma) {
+				{
+				{
+				setState(1802);
+				match(Comma);
+				setState(1803);
+				chain();
+				}
+				}
+				setState(1808);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ChainContext extends ParserRuleContext {
+		public ChainOriginContext chainOrigin() {
+			return getRuleContext(ChainOriginContext.class,0);
+		}
+		public List<MemberAccessContext> memberAccess() {
+			return getRuleContexts(MemberAccessContext.class);
+		}
+		public MemberAccessContext memberAccess(int i) {
+			return getRuleContext(MemberAccessContext.class,i);
+		}
+		public ChainContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_chain; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterChain(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitChain(this);
+		}
+	}
+
+	public final ChainContext chain() throws RecognitionException {
+		ChainContext _localctx = new ChainContext(_ctx, getState());
+		enterRule(_localctx, 236, RULE_chain);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1809);
+			chainOrigin();
+			setState(1813);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,231,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(1810);
+					memberAccess();
+					}
+					} 
+				}
+				setState(1815);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,231,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ChainOriginContext extends ParserRuleContext {
+		public ChainBaseContext chainBase() {
+			return getRuleContext(ChainBaseContext.class,0);
+		}
+		public FunctionCallContext functionCall() {
+			return getRuleContext(FunctionCallContext.class,0);
+		}
+		public NewExprContext newExpr() {
+			return getRuleContext(NewExprContext.class,0);
+		}
+		public ChainOriginContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_chainOrigin; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterChainOrigin(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitChainOrigin(this);
+		}
+	}
+
+	public final ChainOriginContext chainOrigin() throws RecognitionException {
+		ChainOriginContext _localctx = new ChainOriginContext(_ctx, getState());
+		enterRule(_localctx, 238, RULE_chainOrigin);
+		try {
+			setState(1822);
+			switch ( getInterpreter().adaptivePredict(_input,232,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1816);
+				chainBase();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1817);
+				functionCall();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(1818);
+				match(OpenRoundBracket);
+				setState(1819);
+				newExpr();
+				setState(1820);
+				match(CloseRoundBracket);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class MemberAccessContext extends ParserRuleContext {
+		public KeyedFieldNameContext keyedFieldName() {
+			return getRuleContext(KeyedFieldNameContext.class,0);
+		}
+		public ActualArgumentsContext actualArguments() {
+			return getRuleContext(ActualArgumentsContext.class,0);
+		}
+		public MemberAccessContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_memberAccess; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMemberAccess(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMemberAccess(this);
+		}
+	}
+
+	public final MemberAccessContext memberAccess() throws RecognitionException {
+		MemberAccessContext _localctx = new MemberAccessContext(_ctx, getState());
+		enterRule(_localctx, 240, RULE_memberAccess);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1824);
+			match(ObjectOperator);
+			setState(1825);
+			keyedFieldName();
+			setState(1827);
+			switch ( getInterpreter().adaptivePredict(_input,233,_ctx) ) {
+			case 1:
+				{
+				setState(1826);
+				actualArguments();
+				}
+				break;
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class FunctionCallContext extends ParserRuleContext {
+		public FunctionCallNameContext functionCallName() {
+			return getRuleContext(FunctionCallNameContext.class,0);
+		}
+		public ActualArgumentsContext actualArguments() {
+			return getRuleContext(ActualArgumentsContext.class,0);
+		}
+		public FunctionCallContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_functionCall; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterFunctionCall(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitFunctionCall(this);
+		}
+	}
+
+	public final FunctionCallContext functionCall() throws RecognitionException {
+		FunctionCallContext _localctx = new FunctionCallContext(_ctx, getState());
+		enterRule(_localctx, 242, RULE_functionCall);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1829);
+			functionCallName();
+			setState(1830);
+			actualArguments();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class FunctionCallNameContext extends ParserRuleContext {
+		public QualifiedNamespaceNameContext qualifiedNamespaceName() {
+			return getRuleContext(QualifiedNamespaceNameContext.class,0);
+		}
+		public ClassConstantContext classConstant() {
+			return getRuleContext(ClassConstantContext.class,0);
+		}
+		public ChainBaseContext chainBase() {
+			return getRuleContext(ChainBaseContext.class,0);
+		}
+		public ParenthesesContext parentheses() {
+			return getRuleContext(ParenthesesContext.class,0);
+		}
+		public FunctionCallNameContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_functionCallName; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterFunctionCallName(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitFunctionCallName(this);
+		}
+	}
+
+	public final FunctionCallNameContext functionCallName() throws RecognitionException {
+		FunctionCallNameContext _localctx = new FunctionCallNameContext(_ctx, getState());
+		enterRule(_localctx, 244, RULE_functionCallName);
+		try {
+			setState(1836);
+			switch ( getInterpreter().adaptivePredict(_input,234,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1832);
+				qualifiedNamespaceName();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1833);
+				classConstant();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(1834);
+				chainBase();
+				}
+				break;
+			case 4:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(1835);
+				parentheses();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ActualArgumentsContext extends ParserRuleContext {
+		public GenericDynamicArgsContext genericDynamicArgs() {
+			return getRuleContext(GenericDynamicArgsContext.class,0);
+		}
+		public List<ArgumentsContext> arguments() {
+			return getRuleContexts(ArgumentsContext.class);
+		}
+		public ArgumentsContext arguments(int i) {
+			return getRuleContext(ArgumentsContext.class,i);
+		}
+		public List<SquareCurlyExpressionContext> squareCurlyExpression() {
+			return getRuleContexts(SquareCurlyExpressionContext.class);
+		}
+		public SquareCurlyExpressionContext squareCurlyExpression(int i) {
+			return getRuleContext(SquareCurlyExpressionContext.class,i);
+		}
+		public ActualArgumentsContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_actualArguments; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterActualArguments(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitActualArguments(this);
+		}
+	}
+
+	public final ActualArgumentsContext actualArguments() throws RecognitionException {
+		ActualArgumentsContext _localctx = new ActualArgumentsContext(_ctx, getState());
+		enterRule(_localctx, 246, RULE_actualArguments);
+		int _la;
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1839);
+			_la = _input.LA(1);
+			if (_la==Lgeneric) {
+				{
+				setState(1838);
+				genericDynamicArgs();
+				}
+			}
+
+			setState(1842); 
+			_errHandler.sync(this);
+			_alt = 1;
+			do {
+				switch (_alt) {
+				case 1:
+					{
+					{
+					setState(1841);
+					arguments();
+					}
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				setState(1844); 
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,236,_ctx);
+			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+			setState(1849);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,237,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(1846);
+					squareCurlyExpression();
+					}
+					} 
+				}
+				setState(1851);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,237,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ChainBaseContext extends ParserRuleContext {
+		public List<KeyedVariableContext> keyedVariable() {
+			return getRuleContexts(KeyedVariableContext.class);
+		}
+		public KeyedVariableContext keyedVariable(int i) {
+			return getRuleContext(KeyedVariableContext.class,i);
+		}
+		public QualifiedStaticTypeRefContext qualifiedStaticTypeRef() {
+			return getRuleContext(QualifiedStaticTypeRefContext.class,0);
+		}
+		public ChainBaseContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_chainBase; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterChainBase(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitChainBase(this);
+		}
+	}
+
+	public final ChainBaseContext chainBase() throws RecognitionException {
+		ChainBaseContext _localctx = new ChainBaseContext(_ctx, getState());
+		enterRule(_localctx, 248, RULE_chainBase);
+		try {
+			setState(1861);
+			switch (_input.LA(1)) {
+			case Dollar:
+			case VarName:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1852);
+				keyedVariable();
+				setState(1855);
+				switch ( getInterpreter().adaptivePredict(_input,238,_ctx) ) {
+				case 1:
+					{
+					setState(1853);
+					match(DoubleColon);
+					setState(1854);
+					keyedVariable();
+					}
+					break;
+				}
+				}
+				break;
+			case Abstract:
+			case Array:
+			case As:
+			case BinaryCast:
+			case BoolType:
+			case BooleanConstant:
+			case Break:
+			case Callable:
+			case Case:
+			case Catch:
+			case Class:
+			case Clone:
+			case Const:
+			case Continue:
+			case Declare:
+			case Default:
+			case Do:
+			case DoubleCast:
+			case DoubleType:
+			case Echo:
+			case Else:
+			case ElseIf:
+			case Empty:
+			case Enum_:
+			case EndDeclare:
+			case EndFor:
+			case EndForeach:
+			case EndIf:
+			case EndSwitch:
+			case EndWhile:
+			case Eval:
+			case Exit:
+			case Extends:
+			case Final:
+			case Finally:
+			case FloatCast:
+			case For:
+			case Foreach:
+			case Function_:
+			case Global:
+			case Goto:
+			case If:
+			case Implements:
+			case Import:
+			case Include:
+			case IncludeOnce:
+			case InstanceOf:
+			case InsteadOf:
+			case Int8Cast:
+			case Int16Cast:
+			case Int64Type:
+			case IntType:
+			case Interface:
+			case IsSet:
+			case List:
+			case LogicalAnd:
+			case LogicalOr:
+			case LogicalXor:
+			case Match_:
+			case Namespace:
+			case New:
+			case Null:
+			case ObjectType:
+			case Parent_:
+			case Partial:
+			case Print:
+			case Private:
+			case Protected:
+			case Public:
+			case Readonly:
+			case Require:
+			case RequireOnce:
+			case Resource:
+			case Return:
+			case Static:
+			case StringType:
+			case Switch:
+			case Throw:
+			case Trait:
+			case Try:
+			case Typeof:
+			case UintCast:
+			case UnicodeCast:
+			case Unset:
+			case Use:
+			case Var:
+			case While:
+			case Yield:
+			case From:
+			case LambdaFn:
+			case Ticks:
+			case Encoding:
+			case StrictTypes:
+			case Get:
+			case Set:
+			case Call:
+			case CallStatic:
+			case Constructor:
+			case Destruct:
+			case Wakeup:
+			case Sleep:
+			case Autoload:
+			case IsSet__:
+			case Unset__:
+			case ToString__:
+			case Invoke:
+			case SetState:
+			case Clone__:
+			case DebugInfo:
+			case Namespace__:
+			case Class__:
+			case Traic__:
+			case Function__:
+			case Method__:
+			case Line__:
+			case File__:
+			case Dir__:
+			case NamespaceSeparator:
+			case Label:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1857);
+				qualifiedStaticTypeRef();
+				setState(1858);
+				match(DoubleColon);
+				setState(1859);
+				keyedVariable();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class KeyedFieldNameContext extends ParserRuleContext {
+		public KeyedSimpleFieldNameContext keyedSimpleFieldName() {
+			return getRuleContext(KeyedSimpleFieldNameContext.class,0);
+		}
+		public KeyedVariableContext keyedVariable() {
+			return getRuleContext(KeyedVariableContext.class,0);
+		}
+		public KeyedFieldNameContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_keyedFieldName; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterKeyedFieldName(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitKeyedFieldName(this);
+		}
+	}
+
+	public final KeyedFieldNameContext keyedFieldName() throws RecognitionException {
+		KeyedFieldNameContext _localctx = new KeyedFieldNameContext(_ctx, getState());
+		enterRule(_localctx, 250, RULE_keyedFieldName);
+		try {
+			setState(1865);
+			switch (_input.LA(1)) {
+			case Abstract:
+			case Array:
+			case As:
+			case BinaryCast:
+			case BoolType:
+			case BooleanConstant:
+			case Break:
+			case Callable:
+			case Case:
+			case Catch:
+			case Class:
+			case Clone:
+			case Const:
+			case Continue:
+			case Declare:
+			case Default:
+			case Do:
+			case DoubleCast:
+			case DoubleType:
+			case Echo:
+			case Else:
+			case ElseIf:
+			case Empty:
+			case Enum_:
+			case EndDeclare:
+			case EndFor:
+			case EndForeach:
+			case EndIf:
+			case EndSwitch:
+			case EndWhile:
+			case Eval:
+			case Exit:
+			case Extends:
+			case Final:
+			case Finally:
+			case FloatCast:
+			case For:
+			case Foreach:
+			case Function_:
+			case Global:
+			case Goto:
+			case If:
+			case Implements:
+			case Import:
+			case Include:
+			case IncludeOnce:
+			case InstanceOf:
+			case InsteadOf:
+			case Int8Cast:
+			case Int16Cast:
+			case Int64Type:
+			case IntType:
+			case Interface:
+			case IsSet:
+			case List:
+			case LogicalAnd:
+			case LogicalOr:
+			case LogicalXor:
+			case Match_:
+			case Namespace:
+			case New:
+			case Null:
+			case ObjectType:
+			case Parent_:
+			case Partial:
+			case Print:
+			case Private:
+			case Protected:
+			case Public:
+			case Readonly:
+			case Require:
+			case RequireOnce:
+			case Resource:
+			case Return:
+			case Static:
+			case StringType:
+			case Switch:
+			case Throw:
+			case Trait:
+			case Try:
+			case Typeof:
+			case UintCast:
+			case UnicodeCast:
+			case Unset:
+			case Use:
+			case Var:
+			case While:
+			case Yield:
+			case From:
+			case LambdaFn:
+			case Ticks:
+			case Encoding:
+			case StrictTypes:
+			case Get:
+			case Set:
+			case Call:
+			case CallStatic:
+			case Constructor:
+			case Destruct:
+			case Wakeup:
+			case Sleep:
+			case Autoload:
+			case IsSet__:
+			case Unset__:
+			case ToString__:
+			case Invoke:
+			case SetState:
+			case Clone__:
+			case DebugInfo:
+			case Namespace__:
+			case Class__:
+			case Traic__:
+			case Function__:
+			case Method__:
+			case Line__:
+			case File__:
+			case Dir__:
+			case OpenCurlyBracket:
+			case Label:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1863);
+				keyedSimpleFieldName();
+				}
+				break;
+			case Dollar:
+			case VarName:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1864);
+				keyedVariable();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class KeyedSimpleFieldNameContext extends ParserRuleContext {
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); }
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); }
+		public List<SquareCurlyExpressionContext> squareCurlyExpression() {
+			return getRuleContexts(SquareCurlyExpressionContext.class);
+		}
+		public SquareCurlyExpressionContext squareCurlyExpression(int i) {
+			return getRuleContext(SquareCurlyExpressionContext.class,i);
+		}
+		public KeyedSimpleFieldNameContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_keyedSimpleFieldName; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterKeyedSimpleFieldName(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitKeyedSimpleFieldName(this);
+		}
+	}
+
+	public final KeyedSimpleFieldNameContext keyedSimpleFieldName() throws RecognitionException {
+		KeyedSimpleFieldNameContext _localctx = new KeyedSimpleFieldNameContext(_ctx, getState());
+		enterRule(_localctx, 252, RULE_keyedSimpleFieldName);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1872);
+			switch (_input.LA(1)) {
+			case Abstract:
+			case Array:
+			case As:
+			case BinaryCast:
+			case BoolType:
+			case BooleanConstant:
+			case Break:
+			case Callable:
+			case Case:
+			case Catch:
+			case Class:
+			case Clone:
+			case Const:
+			case Continue:
+			case Declare:
+			case Default:
+			case Do:
+			case DoubleCast:
+			case DoubleType:
+			case Echo:
+			case Else:
+			case ElseIf:
+			case Empty:
+			case Enum_:
+			case EndDeclare:
+			case EndFor:
+			case EndForeach:
+			case EndIf:
+			case EndSwitch:
+			case EndWhile:
+			case Eval:
+			case Exit:
+			case Extends:
+			case Final:
+			case Finally:
+			case FloatCast:
+			case For:
+			case Foreach:
+			case Function_:
+			case Global:
+			case Goto:
+			case If:
+			case Implements:
+			case Import:
+			case Include:
+			case IncludeOnce:
+			case InstanceOf:
+			case InsteadOf:
+			case Int8Cast:
+			case Int16Cast:
+			case Int64Type:
+			case IntType:
+			case Interface:
+			case IsSet:
+			case List:
+			case LogicalAnd:
+			case LogicalOr:
+			case LogicalXor:
+			case Match_:
+			case Namespace:
+			case New:
+			case Null:
+			case ObjectType:
+			case Parent_:
+			case Partial:
+			case Print:
+			case Private:
+			case Protected:
+			case Public:
+			case Readonly:
+			case Require:
+			case RequireOnce:
+			case Resource:
+			case Return:
+			case Static:
+			case StringType:
+			case Switch:
+			case Throw:
+			case Trait:
+			case Try:
+			case Typeof:
+			case UintCast:
+			case UnicodeCast:
+			case Unset:
+			case Use:
+			case Var:
+			case While:
+			case Yield:
+			case From:
+			case LambdaFn:
+			case Ticks:
+			case Encoding:
+			case StrictTypes:
+			case Get:
+			case Set:
+			case Call:
+			case CallStatic:
+			case Constructor:
+			case Destruct:
+			case Wakeup:
+			case Sleep:
+			case Autoload:
+			case IsSet__:
+			case Unset__:
+			case ToString__:
+			case Invoke:
+			case SetState:
+			case Clone__:
+			case DebugInfo:
+			case Namespace__:
+			case Class__:
+			case Traic__:
+			case Function__:
+			case Method__:
+			case Line__:
+			case File__:
+			case Dir__:
+			case Label:
+				{
+				setState(1867);
+				identifier();
+				}
+				break;
+			case OpenCurlyBracket:
+				{
+				setState(1868);
+				match(OpenCurlyBracket);
+				setState(1869);
+				expression(0);
+				setState(1870);
+				match(CloseCurlyBracket);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+			setState(1877);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,242,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(1874);
+					squareCurlyExpression();
+					}
+					} 
+				}
+				setState(1879);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,242,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class KeyedVariableContext extends ParserRuleContext {
+		public TerminalNode VarName() { return getToken(PhpParser.VarName, 0); }
+		public List<TerminalNode> Dollar() { return getTokens(PhpParser.Dollar); }
+		public TerminalNode Dollar(int i) {
+			return getToken(PhpParser.Dollar, i);
+		}
+		public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); }
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); }
+		public List<SquareCurlyExpressionContext> squareCurlyExpression() {
+			return getRuleContexts(SquareCurlyExpressionContext.class);
+		}
+		public SquareCurlyExpressionContext squareCurlyExpression(int i) {
+			return getRuleContext(SquareCurlyExpressionContext.class,i);
+		}
+		public KeyedVariableContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_keyedVariable; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterKeyedVariable(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitKeyedVariable(this);
+		}
+	}
+
+	public final KeyedVariableContext keyedVariable() throws RecognitionException {
+		KeyedVariableContext _localctx = new KeyedVariableContext(_ctx, getState());
+		enterRule(_localctx, 254, RULE_keyedVariable);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1883);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,243,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(1880);
+					match(Dollar);
+					}
+					} 
+				}
+				setState(1885);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,243,_ctx);
+			}
+			setState(1892);
+			switch (_input.LA(1)) {
+			case VarName:
+				{
+				setState(1886);
+				match(VarName);
+				}
+				break;
+			case Dollar:
+				{
+				setState(1887);
+				match(Dollar);
+				setState(1888);
+				match(OpenCurlyBracket);
+				setState(1889);
+				expression(0);
+				setState(1890);
+				match(CloseCurlyBracket);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+			setState(1897);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,245,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(1894);
+					squareCurlyExpression();
+					}
+					} 
+				}
+				setState(1899);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,245,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class SquareCurlyExpressionContext extends ParserRuleContext {
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public TerminalNode OpenCurlyBracket() { return getToken(PhpParser.OpenCurlyBracket, 0); }
+		public TerminalNode CloseCurlyBracket() { return getToken(PhpParser.CloseCurlyBracket, 0); }
+		public SquareCurlyExpressionContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_squareCurlyExpression; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterSquareCurlyExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitSquareCurlyExpression(this);
+		}
+	}
+
+	public final SquareCurlyExpressionContext squareCurlyExpression() throws RecognitionException {
+		SquareCurlyExpressionContext _localctx = new SquareCurlyExpressionContext(_ctx, getState());
+		enterRule(_localctx, 256, RULE_squareCurlyExpression);
+		int _la;
+		try {
+			setState(1909);
+			switch (_input.LA(1)) {
+			case OpenSquareBracket:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1900);
+				match(OpenSquareBracket);
+				setState(1902);
+				_la = _input.LA(1);
+				if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) {
+					{
+					setState(1901);
+					expression(0);
+					}
+				}
+
+				setState(1904);
+				match(CloseSquareBracket);
+				}
+				break;
+			case OpenCurlyBracket:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1905);
+				match(OpenCurlyBracket);
+				setState(1906);
+				expression(0);
+				setState(1907);
+				match(CloseCurlyBracket);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class AssignmentListContext extends ParserRuleContext {
+		public List<AssignmentListElementContext> assignmentListElement() {
+			return getRuleContexts(AssignmentListElementContext.class);
+		}
+		public AssignmentListElementContext assignmentListElement(int i) {
+			return getRuleContext(AssignmentListElementContext.class,i);
+		}
+		public AssignmentListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_assignmentList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAssignmentList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAssignmentList(this);
+		}
+	}
+
+	public final AssignmentListContext assignmentList() throws RecognitionException {
+		AssignmentListContext _localctx = new AssignmentListContext(_ctx, getState());
+		enterRule(_localctx, 258, RULE_assignmentList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1912);
+			_la = _input.LA(1);
+			if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Ampersand - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) {
+				{
+				setState(1911);
+				assignmentListElement();
+				}
+			}
+
+			setState(1920);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==Comma) {
+				{
+				{
+				setState(1914);
+				match(Comma);
+				setState(1916);
+				_la = _input.LA(1);
+				if (((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)) | (1L << (Inc - 108)) | (1L << (Dec - 108)))) != 0) || ((((_la - 194)) & ~0x3f) == 0 && ((1L << (_la - 194)) & ((1L << (NamespaceSeparator - 194)) | (1L << (Ampersand - 194)) | (1L << (Bang - 194)) | (1L << (Plus - 194)) | (1L << (Minus - 194)) | (1L << (Tilde - 194)) | (1L << (SuppressWarnings - 194)) | (1L << (Dollar - 194)) | (1L << (OpenRoundBracket - 194)) | (1L << (OpenSquareBracket - 194)) | (1L << (VarName - 194)) | (1L << (Label - 194)) | (1L << (Octal - 194)) | (1L << (Decimal - 194)) | (1L << (Real - 194)) | (1L << (Hex - 194)) | (1L << (Binary - 194)) | (1L << (BackQuoteString - 194)) | (1L << (SingleQuoteString - 194)) | (1L << (DoubleQuote - 194)) | (1L << (StartNowDoc - 194)) | (1L << (StartHereDoc - 194)))) != 0)) {
+					{
+					setState(1915);
+					assignmentListElement();
+					}
+				}
+
+				}
+				}
+				setState(1922);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class AssignmentListElementContext extends ParserRuleContext {
+		public ChainContext chain() {
+			return getRuleContext(ChainContext.class,0);
+		}
+		public TerminalNode List() { return getToken(PhpParser.List, 0); }
+		public AssignmentListContext assignmentList() {
+			return getRuleContext(AssignmentListContext.class,0);
+		}
+		public ArrayItemContext arrayItem() {
+			return getRuleContext(ArrayItemContext.class,0);
+		}
+		public AssignmentListElementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_assignmentListElement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterAssignmentListElement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitAssignmentListElement(this);
+		}
+	}
+
+	public final AssignmentListElementContext assignmentListElement() throws RecognitionException {
+		AssignmentListElementContext _localctx = new AssignmentListElementContext(_ctx, getState());
+		enterRule(_localctx, 260, RULE_assignmentListElement);
+		try {
+			setState(1930);
+			switch ( getInterpreter().adaptivePredict(_input,251,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1923);
+				chain();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1924);
+				match(List);
+				setState(1925);
+				match(OpenRoundBracket);
+				setState(1926);
+				assignmentList();
+				setState(1927);
+				match(CloseRoundBracket);
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(1929);
+				arrayItem();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ModifierContext extends ParserRuleContext {
+		public TerminalNode Abstract() { return getToken(PhpParser.Abstract, 0); }
+		public TerminalNode Final() { return getToken(PhpParser.Final, 0); }
+		public ModifierContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_modifier; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterModifier(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitModifier(this);
+		}
+	}
+
+	public final ModifierContext modifier() throws RecognitionException {
+		ModifierContext _localctx = new ModifierContext(_ctx, getState());
+		enterRule(_localctx, 262, RULE_modifier);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1932);
+			_la = _input.LA(1);
+			if ( !(_la==Abstract || _la==Final) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class IdentifierContext extends ParserRuleContext {
+		public TerminalNode Label() { return getToken(PhpParser.Label, 0); }
+		public TerminalNode Abstract() { return getToken(PhpParser.Abstract, 0); }
+		public TerminalNode Array() { return getToken(PhpParser.Array, 0); }
+		public TerminalNode As() { return getToken(PhpParser.As, 0); }
+		public TerminalNode BinaryCast() { return getToken(PhpParser.BinaryCast, 0); }
+		public TerminalNode BoolType() { return getToken(PhpParser.BoolType, 0); }
+		public TerminalNode BooleanConstant() { return getToken(PhpParser.BooleanConstant, 0); }
+		public TerminalNode Break() { return getToken(PhpParser.Break, 0); }
+		public TerminalNode Callable() { return getToken(PhpParser.Callable, 0); }
+		public TerminalNode Case() { return getToken(PhpParser.Case, 0); }
+		public TerminalNode Catch() { return getToken(PhpParser.Catch, 0); }
+		public TerminalNode Class() { return getToken(PhpParser.Class, 0); }
+		public TerminalNode Clone() { return getToken(PhpParser.Clone, 0); }
+		public TerminalNode Const() { return getToken(PhpParser.Const, 0); }
+		public TerminalNode Continue() { return getToken(PhpParser.Continue, 0); }
+		public TerminalNode Declare() { return getToken(PhpParser.Declare, 0); }
+		public TerminalNode Default() { return getToken(PhpParser.Default, 0); }
+		public TerminalNode Do() { return getToken(PhpParser.Do, 0); }
+		public TerminalNode DoubleCast() { return getToken(PhpParser.DoubleCast, 0); }
+		public TerminalNode DoubleType() { return getToken(PhpParser.DoubleType, 0); }
+		public TerminalNode Echo() { return getToken(PhpParser.Echo, 0); }
+		public TerminalNode Else() { return getToken(PhpParser.Else, 0); }
+		public TerminalNode ElseIf() { return getToken(PhpParser.ElseIf, 0); }
+		public TerminalNode Empty() { return getToken(PhpParser.Empty, 0); }
+		public TerminalNode EndDeclare() { return getToken(PhpParser.EndDeclare, 0); }
+		public TerminalNode EndFor() { return getToken(PhpParser.EndFor, 0); }
+		public TerminalNode EndForeach() { return getToken(PhpParser.EndForeach, 0); }
+		public TerminalNode EndIf() { return getToken(PhpParser.EndIf, 0); }
+		public TerminalNode EndSwitch() { return getToken(PhpParser.EndSwitch, 0); }
+		public TerminalNode EndWhile() { return getToken(PhpParser.EndWhile, 0); }
+		public TerminalNode Eval() { return getToken(PhpParser.Eval, 0); }
+		public TerminalNode Exit() { return getToken(PhpParser.Exit, 0); }
+		public TerminalNode Extends() { return getToken(PhpParser.Extends, 0); }
+		public TerminalNode Final() { return getToken(PhpParser.Final, 0); }
+		public TerminalNode Finally() { return getToken(PhpParser.Finally, 0); }
+		public TerminalNode FloatCast() { return getToken(PhpParser.FloatCast, 0); }
+		public TerminalNode For() { return getToken(PhpParser.For, 0); }
+		public TerminalNode Foreach() { return getToken(PhpParser.Foreach, 0); }
+		public TerminalNode Function_() { return getToken(PhpParser.Function_, 0); }
+		public TerminalNode Global() { return getToken(PhpParser.Global, 0); }
+		public TerminalNode Goto() { return getToken(PhpParser.Goto, 0); }
+		public TerminalNode If() { return getToken(PhpParser.If, 0); }
+		public TerminalNode Implements() { return getToken(PhpParser.Implements, 0); }
+		public TerminalNode Import() { return getToken(PhpParser.Import, 0); }
+		public TerminalNode Include() { return getToken(PhpParser.Include, 0); }
+		public TerminalNode IncludeOnce() { return getToken(PhpParser.IncludeOnce, 0); }
+		public TerminalNode InstanceOf() { return getToken(PhpParser.InstanceOf, 0); }
+		public TerminalNode InsteadOf() { return getToken(PhpParser.InsteadOf, 0); }
+		public TerminalNode Int16Cast() { return getToken(PhpParser.Int16Cast, 0); }
+		public TerminalNode Int64Type() { return getToken(PhpParser.Int64Type, 0); }
+		public TerminalNode Int8Cast() { return getToken(PhpParser.Int8Cast, 0); }
+		public TerminalNode Interface() { return getToken(PhpParser.Interface, 0); }
+		public TerminalNode IntType() { return getToken(PhpParser.IntType, 0); }
+		public TerminalNode IsSet() { return getToken(PhpParser.IsSet, 0); }
+		public TerminalNode LambdaFn() { return getToken(PhpParser.LambdaFn, 0); }
+		public TerminalNode List() { return getToken(PhpParser.List, 0); }
+		public TerminalNode LogicalAnd() { return getToken(PhpParser.LogicalAnd, 0); }
+		public TerminalNode LogicalOr() { return getToken(PhpParser.LogicalOr, 0); }
+		public TerminalNode LogicalXor() { return getToken(PhpParser.LogicalXor, 0); }
+		public TerminalNode Namespace() { return getToken(PhpParser.Namespace, 0); }
+		public TerminalNode New() { return getToken(PhpParser.New, 0); }
+		public TerminalNode Null() { return getToken(PhpParser.Null, 0); }
+		public TerminalNode ObjectType() { return getToken(PhpParser.ObjectType, 0); }
+		public TerminalNode Parent_() { return getToken(PhpParser.Parent_, 0); }
+		public TerminalNode Partial() { return getToken(PhpParser.Partial, 0); }
+		public TerminalNode Print() { return getToken(PhpParser.Print, 0); }
+		public TerminalNode Private() { return getToken(PhpParser.Private, 0); }
+		public TerminalNode Protected() { return getToken(PhpParser.Protected, 0); }
+		public TerminalNode Public() { return getToken(PhpParser.Public, 0); }
+		public TerminalNode Readonly() { return getToken(PhpParser.Readonly, 0); }
+		public TerminalNode Require() { return getToken(PhpParser.Require, 0); }
+		public TerminalNode RequireOnce() { return getToken(PhpParser.RequireOnce, 0); }
+		public TerminalNode Resource() { return getToken(PhpParser.Resource, 0); }
+		public TerminalNode Return() { return getToken(PhpParser.Return, 0); }
+		public TerminalNode Static() { return getToken(PhpParser.Static, 0); }
+		public TerminalNode StringType() { return getToken(PhpParser.StringType, 0); }
+		public TerminalNode Switch() { return getToken(PhpParser.Switch, 0); }
+		public TerminalNode Throw() { return getToken(PhpParser.Throw, 0); }
+		public TerminalNode Trait() { return getToken(PhpParser.Trait, 0); }
+		public TerminalNode Try() { return getToken(PhpParser.Try, 0); }
+		public TerminalNode Typeof() { return getToken(PhpParser.Typeof, 0); }
+		public TerminalNode UintCast() { return getToken(PhpParser.UintCast, 0); }
+		public TerminalNode UnicodeCast() { return getToken(PhpParser.UnicodeCast, 0); }
+		public TerminalNode Unset() { return getToken(PhpParser.Unset, 0); }
+		public TerminalNode Use() { return getToken(PhpParser.Use, 0); }
+		public TerminalNode Var() { return getToken(PhpParser.Var, 0); }
+		public TerminalNode While() { return getToken(PhpParser.While, 0); }
+		public TerminalNode Yield() { return getToken(PhpParser.Yield, 0); }
+		public TerminalNode From() { return getToken(PhpParser.From, 0); }
+		public TerminalNode Enum_() { return getToken(PhpParser.Enum_, 0); }
+		public TerminalNode Match_() { return getToken(PhpParser.Match_, 0); }
+		public TerminalNode Ticks() { return getToken(PhpParser.Ticks, 0); }
+		public TerminalNode Encoding() { return getToken(PhpParser.Encoding, 0); }
+		public TerminalNode StrictTypes() { return getToken(PhpParser.StrictTypes, 0); }
+		public TerminalNode Get() { return getToken(PhpParser.Get, 0); }
+		public TerminalNode Set() { return getToken(PhpParser.Set, 0); }
+		public TerminalNode Call() { return getToken(PhpParser.Call, 0); }
+		public TerminalNode CallStatic() { return getToken(PhpParser.CallStatic, 0); }
+		public TerminalNode Constructor() { return getToken(PhpParser.Constructor, 0); }
+		public TerminalNode Destruct() { return getToken(PhpParser.Destruct, 0); }
+		public TerminalNode Wakeup() { return getToken(PhpParser.Wakeup, 0); }
+		public TerminalNode Sleep() { return getToken(PhpParser.Sleep, 0); }
+		public TerminalNode Autoload() { return getToken(PhpParser.Autoload, 0); }
+		public TerminalNode IsSet__() { return getToken(PhpParser.IsSet__, 0); }
+		public TerminalNode Unset__() { return getToken(PhpParser.Unset__, 0); }
+		public TerminalNode ToString__() { return getToken(PhpParser.ToString__, 0); }
+		public TerminalNode Invoke() { return getToken(PhpParser.Invoke, 0); }
+		public TerminalNode SetState() { return getToken(PhpParser.SetState, 0); }
+		public TerminalNode Clone__() { return getToken(PhpParser.Clone__, 0); }
+		public TerminalNode DebugInfo() { return getToken(PhpParser.DebugInfo, 0); }
+		public TerminalNode Namespace__() { return getToken(PhpParser.Namespace__, 0); }
+		public TerminalNode Class__() { return getToken(PhpParser.Class__, 0); }
+		public TerminalNode Traic__() { return getToken(PhpParser.Traic__, 0); }
+		public TerminalNode Function__() { return getToken(PhpParser.Function__, 0); }
+		public TerminalNode Method__() { return getToken(PhpParser.Method__, 0); }
+		public TerminalNode Line__() { return getToken(PhpParser.Line__, 0); }
+		public TerminalNode File__() { return getToken(PhpParser.File__, 0); }
+		public TerminalNode Dir__() { return getToken(PhpParser.Dir__, 0); }
+		public IdentifierContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_identifier; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterIdentifier(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitIdentifier(this);
+		}
+	}
+
+	public final IdentifierContext identifier() throws RecognitionException {
+		IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
+		enterRule(_localctx, 264, RULE_identifier);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1934);
+			_la = _input.LA(1);
+			if ( !(((((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & ((1L << (Abstract - 44)) | (1L << (Array - 44)) | (1L << (As - 44)) | (1L << (BinaryCast - 44)) | (1L << (BoolType - 44)) | (1L << (BooleanConstant - 44)) | (1L << (Break - 44)) | (1L << (Callable - 44)) | (1L << (Case - 44)) | (1L << (Catch - 44)) | (1L << (Class - 44)) | (1L << (Clone - 44)) | (1L << (Const - 44)) | (1L << (Continue - 44)) | (1L << (Declare - 44)) | (1L << (Default - 44)) | (1L << (Do - 44)) | (1L << (DoubleCast - 44)) | (1L << (DoubleType - 44)) | (1L << (Echo - 44)) | (1L << (Else - 44)) | (1L << (ElseIf - 44)) | (1L << (Empty - 44)) | (1L << (Enum_ - 44)) | (1L << (EndDeclare - 44)) | (1L << (EndFor - 44)) | (1L << (EndForeach - 44)) | (1L << (EndIf - 44)) | (1L << (EndSwitch - 44)) | (1L << (EndWhile - 44)) | (1L << (Eval - 44)) | (1L << (Exit - 44)) | (1L << (Extends - 44)) | (1L << (Final - 44)) | (1L << (Finally - 44)) | (1L << (FloatCast - 44)) | (1L << (For - 44)) | (1L << (Foreach - 44)) | (1L << (Function_ - 44)) | (1L << (Global - 44)) | (1L << (Goto - 44)) | (1L << (If - 44)) | (1L << (Implements - 44)) | (1L << (Import - 44)) | (1L << (Include - 44)) | (1L << (IncludeOnce - 44)) | (1L << (InstanceOf - 44)) | (1L << (InsteadOf - 44)) | (1L << (Int8Cast - 44)) | (1L << (Int16Cast - 44)) | (1L << (Int64Type - 44)) | (1L << (IntType - 44)) | (1L << (Interface - 44)) | (1L << (IsSet - 44)) | (1L << (List - 44)) | (1L << (LogicalAnd - 44)) | (1L << (LogicalOr - 44)) | (1L << (LogicalXor - 44)) | (1L << (Match_ - 44)) | (1L << (Namespace - 44)) | (1L << (New - 44)) | (1L << (Null - 44)) | (1L << (ObjectType - 44)) | (1L << (Parent_ - 44)))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (Partial - 108)) | (1L << (Print - 108)) | (1L << (Private - 108)) | (1L << (Protected - 108)) | (1L << (Public - 108)) | (1L << (Readonly - 108)) | (1L << (Require - 108)) | (1L << (RequireOnce - 108)) | (1L << (Resource - 108)) | (1L << (Return - 108)) | (1L << (Static - 108)) | (1L << (StringType - 108)) | (1L << (Switch - 108)) | (1L << (Throw - 108)) | (1L << (Trait - 108)) | (1L << (Try - 108)) | (1L << (Typeof - 108)) | (1L << (UintCast - 108)) | (1L << (UnicodeCast - 108)) | (1L << (Unset - 108)) | (1L << (Use - 108)) | (1L << (Var - 108)) | (1L << (While - 108)) | (1L << (Yield - 108)) | (1L << (From - 108)) | (1L << (LambdaFn - 108)) | (1L << (Ticks - 108)) | (1L << (Encoding - 108)) | (1L << (StrictTypes - 108)) | (1L << (Get - 108)) | (1L << (Set - 108)) | (1L << (Call - 108)) | (1L << (CallStatic - 108)) | (1L << (Constructor - 108)) | (1L << (Destruct - 108)) | (1L << (Wakeup - 108)) | (1L << (Sleep - 108)) | (1L << (Autoload - 108)) | (1L << (IsSet__ - 108)) | (1L << (Unset__ - 108)) | (1L << (ToString__ - 108)) | (1L << (Invoke - 108)) | (1L << (SetState - 108)) | (1L << (Clone__ - 108)) | (1L << (DebugInfo - 108)) | (1L << (Namespace__ - 108)) | (1L << (Class__ - 108)) | (1L << (Traic__ - 108)) | (1L << (Function__ - 108)) | (1L << (Method__ - 108)) | (1L << (Line__ - 108)) | (1L << (File__ - 108)) | (1L << (Dir__ - 108)))) != 0) || _la==Label) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class MemberModifierContext extends ParserRuleContext {
+		public TerminalNode Public() { return getToken(PhpParser.Public, 0); }
+		public TerminalNode Protected() { return getToken(PhpParser.Protected, 0); }
+		public TerminalNode Private() { return getToken(PhpParser.Private, 0); }
+		public TerminalNode Static() { return getToken(PhpParser.Static, 0); }
+		public TerminalNode Abstract() { return getToken(PhpParser.Abstract, 0); }
+		public TerminalNode Final() { return getToken(PhpParser.Final, 0); }
+		public TerminalNode Readonly() { return getToken(PhpParser.Readonly, 0); }
+		public MemberModifierContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_memberModifier; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMemberModifier(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMemberModifier(this);
+		}
+	}
+
+	public final MemberModifierContext memberModifier() throws RecognitionException {
+		MemberModifierContext _localctx = new MemberModifierContext(_ctx, getState());
+		enterRule(_localctx, 266, RULE_memberModifier);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1936);
+			_la = _input.LA(1);
+			if ( !(_la==Abstract || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (Final - 77)) | (1L << (Private - 77)) | (1L << (Protected - 77)) | (1L << (Public - 77)) | (1L << (Readonly - 77)) | (1L << (Static - 77)))) != 0)) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class MagicConstantContext extends ParserRuleContext {
+		public TerminalNode Namespace__() { return getToken(PhpParser.Namespace__, 0); }
+		public TerminalNode Class__() { return getToken(PhpParser.Class__, 0); }
+		public TerminalNode Traic__() { return getToken(PhpParser.Traic__, 0); }
+		public TerminalNode Function__() { return getToken(PhpParser.Function__, 0); }
+		public TerminalNode Method__() { return getToken(PhpParser.Method__, 0); }
+		public TerminalNode Line__() { return getToken(PhpParser.Line__, 0); }
+		public TerminalNode File__() { return getToken(PhpParser.File__, 0); }
+		public TerminalNode Dir__() { return getToken(PhpParser.Dir__, 0); }
+		public MagicConstantContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_magicConstant; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMagicConstant(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMagicConstant(this);
+		}
+	}
+
+	public final MagicConstantContext magicConstant() throws RecognitionException {
+		MagicConstantContext _localctx = new MagicConstantContext(_ctx, getState());
+		enterRule(_localctx, 268, RULE_magicConstant);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1938);
+			_la = _input.LA(1);
+			if ( !(((((_la - 153)) & ~0x3f) == 0 && ((1L << (_la - 153)) & ((1L << (Namespace__ - 153)) | (1L << (Class__ - 153)) | (1L << (Traic__ - 153)) | (1L << (Function__ - 153)) | (1L << (Method__ - 153)) | (1L << (Line__ - 153)) | (1L << (File__ - 153)) | (1L << (Dir__ - 153)))) != 0)) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class MagicMethodContext extends ParserRuleContext {
+		public TerminalNode Get() { return getToken(PhpParser.Get, 0); }
+		public TerminalNode Set() { return getToken(PhpParser.Set, 0); }
+		public TerminalNode Call() { return getToken(PhpParser.Call, 0); }
+		public TerminalNode CallStatic() { return getToken(PhpParser.CallStatic, 0); }
+		public TerminalNode Constructor() { return getToken(PhpParser.Constructor, 0); }
+		public TerminalNode Destruct() { return getToken(PhpParser.Destruct, 0); }
+		public TerminalNode Wakeup() { return getToken(PhpParser.Wakeup, 0); }
+		public TerminalNode Sleep() { return getToken(PhpParser.Sleep, 0); }
+		public TerminalNode Autoload() { return getToken(PhpParser.Autoload, 0); }
+		public TerminalNode IsSet__() { return getToken(PhpParser.IsSet__, 0); }
+		public TerminalNode Unset__() { return getToken(PhpParser.Unset__, 0); }
+		public TerminalNode ToString__() { return getToken(PhpParser.ToString__, 0); }
+		public TerminalNode Invoke() { return getToken(PhpParser.Invoke, 0); }
+		public TerminalNode SetState() { return getToken(PhpParser.SetState, 0); }
+		public TerminalNode Clone__() { return getToken(PhpParser.Clone__, 0); }
+		public TerminalNode DebugInfo() { return getToken(PhpParser.DebugInfo, 0); }
+		public MagicMethodContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_magicMethod; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterMagicMethod(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitMagicMethod(this);
+		}
+	}
+
+	public final MagicMethodContext magicMethod() throws RecognitionException {
+		MagicMethodContext _localctx = new MagicMethodContext(_ctx, getState());
+		enterRule(_localctx, 270, RULE_magicMethod);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1940);
+			_la = _input.LA(1);
+			if ( !(((((_la - 137)) & ~0x3f) == 0 && ((1L << (_la - 137)) & ((1L << (Get - 137)) | (1L << (Set - 137)) | (1L << (Call - 137)) | (1L << (CallStatic - 137)) | (1L << (Constructor - 137)) | (1L << (Destruct - 137)) | (1L << (Wakeup - 137)) | (1L << (Sleep - 137)) | (1L << (Autoload - 137)) | (1L << (IsSet__ - 137)) | (1L << (Unset__ - 137)) | (1L << (ToString__ - 137)) | (1L << (Invoke - 137)) | (1L << (SetState - 137)) | (1L << (Clone__ - 137)) | (1L << (DebugInfo - 137)))) != 0)) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class PrimitiveTypeContext extends ParserRuleContext {
+		public TerminalNode BoolType() { return getToken(PhpParser.BoolType, 0); }
+		public TerminalNode IntType() { return getToken(PhpParser.IntType, 0); }
+		public TerminalNode Int64Type() { return getToken(PhpParser.Int64Type, 0); }
+		public TerminalNode DoubleType() { return getToken(PhpParser.DoubleType, 0); }
+		public TerminalNode StringType() { return getToken(PhpParser.StringType, 0); }
+		public TerminalNode Resource() { return getToken(PhpParser.Resource, 0); }
+		public TerminalNode ObjectType() { return getToken(PhpParser.ObjectType, 0); }
+		public TerminalNode Array() { return getToken(PhpParser.Array, 0); }
+		public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_primitiveType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterPrimitiveType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitPrimitiveType(this);
+		}
+	}
+
+	public final PrimitiveTypeContext primitiveType() throws RecognitionException {
+		PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState());
+		enterRule(_localctx, 272, RULE_primitiveType);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1942);
+			_la = _input.LA(1);
+			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Array) | (1L << BoolType) | (1L << DoubleType))) != 0) || ((((_la - 94)) & ~0x3f) == 0 && ((1L << (_la - 94)) & ((1L << (Int64Type - 94)) | (1L << (IntType - 94)) | (1L << (ObjectType - 94)) | (1L << (Resource - 94)) | (1L << (StringType - 94)))) != 0)) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class CastOperationContext extends ParserRuleContext {
+		public TerminalNode BoolType() { return getToken(PhpParser.BoolType, 0); }
+		public TerminalNode Int8Cast() { return getToken(PhpParser.Int8Cast, 0); }
+		public TerminalNode Int16Cast() { return getToken(PhpParser.Int16Cast, 0); }
+		public TerminalNode IntType() { return getToken(PhpParser.IntType, 0); }
+		public TerminalNode Int64Type() { return getToken(PhpParser.Int64Type, 0); }
+		public TerminalNode UintCast() { return getToken(PhpParser.UintCast, 0); }
+		public TerminalNode DoubleCast() { return getToken(PhpParser.DoubleCast, 0); }
+		public TerminalNode DoubleType() { return getToken(PhpParser.DoubleType, 0); }
+		public TerminalNode FloatCast() { return getToken(PhpParser.FloatCast, 0); }
+		public TerminalNode StringType() { return getToken(PhpParser.StringType, 0); }
+		public TerminalNode BinaryCast() { return getToken(PhpParser.BinaryCast, 0); }
+		public TerminalNode UnicodeCast() { return getToken(PhpParser.UnicodeCast, 0); }
+		public TerminalNode Array() { return getToken(PhpParser.Array, 0); }
+		public TerminalNode ObjectType() { return getToken(PhpParser.ObjectType, 0); }
+		public TerminalNode Resource() { return getToken(PhpParser.Resource, 0); }
+		public TerminalNode Unset() { return getToken(PhpParser.Unset, 0); }
+		public CastOperationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_castOperation; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).enterCastOperation(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof PhpParserListener ) ((PhpParserListener)listener).exitCastOperation(this);
+		}
+	}
+
+	public final CastOperationContext castOperation() throws RecognitionException {
+		CastOperationContext _localctx = new CastOperationContext(_ctx, getState());
+		enterRule(_localctx, 274, RULE_castOperation);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1944);
+			_la = _input.LA(1);
+			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Array) | (1L << BinaryCast) | (1L << BoolType) | (1L << DoubleCast) | (1L << DoubleType))) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & ((1L << (FloatCast - 79)) | (1L << (Int8Cast - 79)) | (1L << (Int16Cast - 79)) | (1L << (Int64Type - 79)) | (1L << (IntType - 79)) | (1L << (ObjectType - 79)) | (1L << (Resource - 79)) | (1L << (StringType - 79)) | (1L << (UintCast - 79)) | (1L << (UnicodeCast - 79)) | (1L << (Unset - 79)))) != 0)) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
+		switch (ruleIndex) {
+		case 59:
+			return typeHint_sempred((TypeHintContext)_localctx, predIndex);
+		case 82:
+			return expression_sempred((ExpressionContext)_localctx, predIndex);
+		}
+		return true;
+	}
+	private boolean typeHint_sempred(TypeHintContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 0:
+			return precpred(_ctx, 1);
+		}
+		return true;
+	}
+	private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 1:
+			return precpred(_ctx, 22);
+		case 2:
+			return precpred(_ctx, 20);
+		case 3:
+			return precpred(_ctx, 19);
+		case 4:
+			return precpred(_ctx, 18);
+		case 5:
+			return precpred(_ctx, 17);
+		case 6:
+			return precpred(_ctx, 16);
+		case 7:
+			return precpred(_ctx, 15);
+		case 8:
+			return precpred(_ctx, 14);
+		case 9:
+			return precpred(_ctx, 13);
+		case 10:
+			return precpred(_ctx, 12);
+		case 11:
+			return precpred(_ctx, 11);
+		case 12:
+			return precpred(_ctx, 10);
+		case 13:
+			return precpred(_ctx, 9);
+		case 14:
+			return precpred(_ctx, 8);
+		case 15:
+			return precpred(_ctx, 3);
+		case 16:
+			return precpred(_ctx, 2);
+		case 17:
+			return precpred(_ctx, 1);
+		case 18:
+			return precpred(_ctx, 21);
+		}
+		return true;
+	}
+
+	public static final String _serializedATN =
+		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\u00f6\u079d\4\2\t"+
+		"\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
+		"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
+		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
+		"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
+		"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
+		",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
+		"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
+		"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
+		"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
+		"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
+		"`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
+		"k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
+		"w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+
+		"\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+
+		"\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+
+		"\4\u008a\t\u008a\4\u008b\t\u008b\3\2\5\2\u0118\n\2\3\2\3\2\7\2\u011c\n"+
+		"\2\f\2\16\2\u011f\13\2\3\2\3\2\3\3\6\3\u0124\n\3\r\3\16\3\u0125\3\3\5"+
+		"\3\u0129\n\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3"+
+		"\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\7\4\u0141\n\4\f\4\16\4\u0144\13\4\3\4\5"+
+		"\4\u0147\n\4\3\5\6\5\u014a\n\5\r\5\16\5\u014b\3\6\7\6\u014f\n\6\f\6\16"+
+		"\6\u0152\13\6\3\6\6\6\u0155\n\6\r\6\16\6\u0156\3\7\3\7\3\7\3\7\3\7\3\b"+
+		"\3\b\3\b\3\b\3\b\3\b\3\b\5\b\u0165\n\b\3\t\3\t\5\t\u0169\n\t\3\t\3\t\3"+
+		"\t\3\n\5\n\u016f\n\n\3\n\3\n\3\n\5\n\u0174\n\n\3\n\7\n\u0177\n\n\f\n\16"+
+		"\n\u017a\13\n\3\13\3\13\3\f\3\f\5\f\u0180\n\f\3\f\3\f\7\f\u0184\n\f\f"+
+		"\f\16\f\u0187\13\f\3\f\3\f\3\f\3\f\5\f\u018d\n\f\3\r\3\r\3\r\3\r\3\r\5"+
+		"\r\u0194\n\r\3\16\5\16\u0197\n\16\3\16\3\16\5\16\u019b\n\16\3\16\3\16"+
+		"\5\16\u019f\n\16\3\16\3\16\3\16\3\16\3\16\5\16\u01a6\n\16\3\16\5\16\u01a9"+
+		"\n\16\3\16\3\16\3\17\5\17\u01ae\n\17\3\17\5\17\u01b1\n\17\3\17\5\17\u01b4"+
+		"\n\17\3\17\5\17\u01b7\n\17\3\17\3\17\3\17\5\17\u01bc\n\17\3\17\3\17\5"+
+		"\17\u01c0\n\17\3\17\3\17\5\17\u01c4\n\17\3\17\3\17\3\17\5\17\u01c9\n\17"+
+		"\3\17\3\17\5\17\u01cd\n\17\5\17\u01cf\n\17\3\17\3\17\7\17\u01d3\n\17\f"+
+		"\17\16\17\u01d6\13\17\3\17\3\17\3\20\3\20\3\21\3\21\3\21\7\21\u01df\n"+
+		"\21\f\21\16\21\u01e2\13\21\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22"+
+		"\3\22\3\22\3\22\3\22\3\22\5\22\u01f2\n\22\3\23\3\23\3\23\7\23\u01f7\n"+
+		"\23\f\23\16\23\u01fa\13\23\3\24\3\24\3\24\7\24\u01ff\n\24\f\24\16\24\u0202"+
+		"\13\24\3\25\5\25\u0205\n\25\3\25\3\25\3\26\5\26\u020a\n\26\3\26\3\26\3"+
+		"\26\3\26\5\26\u0210\n\26\3\27\3\27\3\27\3\27\7\27\u0216\n\27\f\27\16\27"+
+		"\u0219\13\27\3\27\3\27\3\30\6\30\u021e\n\30\r\30\16\30\u021f\3\31\3\31"+
+		"\3\31\3\31\5\31\u0226\n\31\3\31\3\31\3\31\7\31\u022b\n\31\f\31\16\31\u022e"+
+		"\13\31\3\31\3\31\3\32\3\32\5\32\u0234\n\32\3\33\7\33\u0237\n\33\f\33\16"+
+		"\33\u023a\13\33\3\34\3\34\3\34\5\34\u023f\n\34\3\35\3\35\3\35\3\35\3\35"+
+		"\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35"+
+		"\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\5\35\u025c\n\35\3\36\3\36\3\37"+
+		"\3\37\3\37\3\37\3 \3 \3 \3 \7 \u0268\n \f \16 \u026b\13 \3 \5 \u026e\n"+
+		" \3 \3 \3 \3 \3 \7 \u0275\n \f \16 \u0278\13 \3 \5 \u027b\n \3 \3 \3 "+
+		"\5 \u0280\n \3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3$\3$\3$\3$\3%\3"+
+		"%\3%\3%\3%\3%\3%\3%\5%\u029a\n%\3&\3&\3&\3&\3&\3&\3\'\3\'\3\'\5\'\u02a5"+
+		"\n\'\3\'\3\'\5\'\u02a9\n\'\3\'\3\'\5\'\u02ad\n\'\3\'\3\'\3\'\3\'\3\'\3"+
+		"\'\3\'\5\'\u02b6\n\'\3(\3(\3)\3)\3*\3*\3*\3*\5*\u02c0\n*\3*\7*\u02c3\n"+
+		"*\f*\16*\u02c6\13*\3*\3*\3*\5*\u02cb\n*\3*\7*\u02ce\n*\f*\16*\u02d1\13"+
+		"*\3*\3*\5*\u02d5\n*\3+\3+\3+\5+\u02da\n+\3+\6+\u02dd\n+\r+\16+\u02de\3"+
+		"+\3+\3,\3,\5,\u02e5\n,\3,\3,\3-\3-\5-\u02eb\n-\3-\3-\3.\3.\5.\u02f1\n"+
+		".\3.\3.\3/\3/\3/\3\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61"+
+		"\3\61\3\61\3\61\3\61\3\61\3\61\5\61\u0309\n\61\3\61\3\61\3\61\5\61\u030e"+
+		"\n\61\3\61\5\61\u0311\n\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\5\61"+
+		"\u031b\n\61\3\61\5\61\u031e\n\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3"+
+		"\61\3\61\3\61\3\61\5\61\u032b\n\61\3\61\3\61\3\61\3\61\3\61\3\61\5\61"+
+		"\u0333\n\61\3\62\3\62\3\62\6\62\u0338\n\62\r\62\16\62\u0339\3\62\5\62"+
+		"\u033d\n\62\3\62\7\62\u0340\n\62\f\62\16\62\u0343\13\62\3\62\5\62\u0346"+
+		"\n\62\3\63\3\63\3\63\3\63\3\63\7\63\u034d\n\63\f\63\16\63\u0350\13\63"+
+		"\3\63\5\63\u0353\n\63\3\63\3\63\3\63\3\64\3\64\3\64\3\65\3\65\3\65\3\65"+
+		"\3\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67"+
+		"\5\67\u036d\n\67\38\68\u0370\n8\r8\168\u0371\39\39\39\79\u0377\n9\f9\16"+
+		"9\u037a\139\3:\3:\3:\3:\5:\u0380\n:\3:\3:\3:\3:\3:\3:\5:\u0388\n:\3;\5"+
+		";\u038b\n;\3;\3;\7;\u038f\n;\f;\16;\u0392\13;\3;\5;\u0395\n;\3<\5<\u0398"+
+		"\n<\3<\7<\u039b\n<\f<\16<\u039e\13<\3<\5<\u03a1\n<\3<\5<\u03a4\n<\3<\5"+
+		"<\u03a7\n<\3<\5<\u03aa\n<\3<\3<\3=\3=\3=\3=\5=\u03b2\n=\3=\3=\3=\7=\u03b7"+
+		"\n=\f=\16=\u03ba\13=\3>\3>\3>\3>\7>\u03c0\n>\f>\16>\u03c3\13>\3>\3>\3"+
+		"?\3?\3?\3?\3?\3?\3?\3?\5?\u03cf\n?\3@\3@\3@\3@\3A\3A\3A\3A\7A\u03d9\n"+
+		"A\fA\16A\u03dc\13A\3A\3A\3B\5B\u03e1\nB\3B\3B\5B\u03e5\nB\3B\3B\3B\7B"+
+		"\u03ea\nB\fB\16B\u03ed\13B\3B\3B\3B\5B\u03f2\nB\3B\3B\5B\u03f6\nB\3B\3"+
+		"B\3B\7B\u03fb\nB\fB\16B\u03fe\13B\3B\3B\3B\3B\5B\u0404\nB\3B\3B\5B\u0408"+
+		"\nB\3B\3B\3B\3B\3B\5B\u040f\nB\3B\3B\5B\u0413\nB\5B\u0415\nB\3B\3B\3B"+
+		"\3B\5B\u041b\nB\3C\3C\3C\7C\u0420\nC\fC\16C\u0423\13C\3C\5C\u0426\nC\3"+
+		"D\3D\5D\u042a\nD\3E\3E\3E\3E\3E\3E\3E\3F\3F\3F\3F\5F\u0437\nF\3F\5F\u043a"+
+		"\nF\3F\3F\3G\3G\3G\5G\u0441\nG\3G\3G\3H\3H\3H\5H\u0448\nH\3I\3I\5I\u044c"+
+		"\nI\3I\3I\3J\3J\5J\u0452\nJ\3K\3K\5K\u0456\nK\3L\6L\u0459\nL\rL\16L\u045a"+
+		"\3M\3M\3M\5M\u0460\nM\3N\3N\3N\3N\3O\5O\u0467\nO\3O\3O\3O\3O\7O\u046d"+
+		"\nO\fO\16O\u0470\13O\3O\3O\3P\3P\3P\3P\5P\u0478\nP\3P\3P\5P\u047c\nP\3"+
+		"P\3P\7P\u0480\nP\fP\16P\u0483\13P\3P\3P\3Q\3Q\3Q\3Q\5Q\u048b\nQ\3Q\3Q"+
+		"\3Q\5Q\u0490\nQ\3Q\3Q\3Q\3Q\3Q\5Q\u0497\nQ\3R\3R\3R\7R\u049c\nR\fR\16"+
+		"R\u049f\13R\3S\3S\3S\5S\u04a4\nS\3S\3S\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3"+
+		"T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3"+
+		"T\5T\u04ca\nT\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3"+
+		"T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\5T\u04f4"+
+		"\nT\3T\3T\3T\3T\3T\5T\u04fb\nT\3T\3T\3T\5T\u0500\nT\5T\u0502\nT\3T\3T"+
+		"\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T"+
+		"\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\5T\u0528\nT\3T\3T\3T\3T\3T\3T\3T\3T"+
+		"\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3T\7T\u053e\nT\fT\16T\u0541\13T\3U\3"+
+		"U\5U\u0545\nU\3V\3V\3V\5V\u054a\nV\3V\3V\3V\5V\u054f\nV\3V\5V\u0552\n"+
+		"V\3V\3V\3V\3V\5V\u0558\nV\3W\3W\7W\u055c\nW\fW\16W\u055f\13W\3W\3W\6W"+
+		"\u0563\nW\rW\16W\u0564\3W\7W\u0568\nW\fW\16W\u056b\13W\3W\7W\u056e\nW"+
+		"\fW\16W\u0571\13W\3W\3W\3W\3W\3W\6W\u0578\nW\rW\16W\u0579\3W\7W\u057d"+
+		"\nW\fW\16W\u0580\13W\3W\5W\u0583\nW\3W\3W\5W\u0587\nW\3X\5X\u058a\nX\3"+
+		"X\3X\3Y\3Y\3Y\5Y\u0591\nY\3Y\5Y\u0594\nY\3Y\3Y\3Z\5Z\u0599\nZ\3Z\3Z\5"+
+		"Z\u059d\nZ\3Z\3Z\3Z\3Z\5Z\u05a3\nZ\3Z\3Z\5Z\u05a7\nZ\3Z\3Z\3Z\3Z\3Z\3"+
+		"Z\3Z\3Z\3Z\5Z\u05b2\nZ\3[\3[\3[\3[\3[\3[\3[\3[\7[\u05bc\n[\f[\16[\u05bf"+
+		"\13[\3[\5[\u05c2\n[\3[\3[\3\\\3\\\3\\\7\\\u05c9\n\\\f\\\16\\\u05cc\13"+
+		"\\\3\\\3\\\3\\\3]\3]\3]\5]\u05d4\n]\3^\3^\3_\3_\3_\3_\5_\u05dc\n_\3_\3"+
+		"_\5_\u05e0\n_\3`\3`\3`\7`\u05e5\n`\f`\16`\u05e8\13`\3`\5`\u05eb\n`\3a"+
+		"\3a\3a\5a\u05f0\na\3a\3a\3a\5a\u05f5\na\3a\3a\5a\u05f9\na\3b\3b\3b\3b"+
+		"\3b\7b\u0600\nb\fb\16b\u0603\13b\3b\3b\3c\5c\u0608\nc\3c\3c\3d\3d\5d\u060e"+
+		"\nd\3d\5d\u0611\nd\3e\3e\5e\u0615\ne\3e\5e\u0618\ne\3e\3e\3e\5e\u061d"+
+		"\ne\3f\5f\u0620\nf\3f\5f\u0623\nf\3f\5f\u0626\nf\3f\5f\u0629\nf\3f\3f"+
+		"\5f\u062d\nf\3f\3f\5f\u0631\nf\3f\3f\5f\u0635\nf\3f\3f\3f\5f\u063a\nf"+
+		"\3f\3f\5f\u063e\nf\5f\u0640\nf\3f\3f\7f\u0644\nf\ff\16f\u0647\13f\3f\3"+
+		"f\3g\3g\3g\7g\u064e\ng\fg\16g\u0651\13g\3h\5h\u0654\nh\3h\5h\u0657\nh"+
+		"\3h\3h\3i\3i\3i\3i\7i\u065f\ni\fi\16i\u0662\13i\3i\3i\5i\u0666\ni\5i\u0668"+
+		"\ni\3j\3j\3j\5j\u066d\nj\3j\3j\3j\3j\7j\u0673\nj\fj\16j\u0676\13j\3j\5"+
+		"j\u0679\nj\3j\3j\5j\u067d\nj\3k\3k\3k\7k\u0682\nk\fk\16k\u0685\13k\3l"+
+		"\3l\3l\3l\7l\u068b\nl\fl\16l\u068e\13l\3l\5l\u0691\nl\3l\5l\u0694\nl\3"+
+		"l\3l\3m\5m\u0699\nm\3m\5m\u069c\nm\3m\3m\3m\5m\u06a1\nm\3n\3n\3n\3o\3"+
+		"o\3o\3o\3o\3o\5o\u06ac\no\5o\u06ae\no\3o\3o\3o\3o\5o\u06b4\no\5o\u06b6"+
+		"\no\3o\3o\3o\3o\3o\5o\u06bd\no\3o\3o\3o\5o\u06c2\no\7o\u06c4\no\fo\16"+
+		"o\u06c7\13o\5o\u06c9\no\3p\3p\3p\3p\3p\5p\u06d0\np\3q\3q\3q\3q\5q\u06d6"+
+		"\nq\3r\3r\3s\3s\3s\3s\3s\3s\5s\u06e0\ns\3s\3s\3s\5s\u06e5\ns\3s\3s\3s"+
+		"\5s\u06ea\ns\5s\u06ec\ns\3t\3t\3u\3u\6u\u06f2\nu\ru\16u\u06f3\3u\3u\6"+
+		"u\u06f8\nu\ru\16u\u06f9\3u\3u\3u\7u\u06ff\nu\fu\16u\u0702\13u\3u\5u\u0705"+
+		"\nu\3v\3v\3v\5v\u070a\nv\3w\3w\3w\7w\u070f\nw\fw\16w\u0712\13w\3x\3x\7"+
+		"x\u0716\nx\fx\16x\u0719\13x\3y\3y\3y\3y\3y\3y\5y\u0721\ny\3z\3z\3z\5z"+
+		"\u0726\nz\3{\3{\3{\3|\3|\3|\3|\5|\u072f\n|\3}\5}\u0732\n}\3}\6}\u0735"+
+		"\n}\r}\16}\u0736\3}\7}\u073a\n}\f}\16}\u073d\13}\3~\3~\3~\5~\u0742\n~"+
+		"\3~\3~\3~\3~\5~\u0748\n~\3\177\3\177\5\177\u074c\n\177\3\u0080\3\u0080"+
+		"\3\u0080\3\u0080\3\u0080\5\u0080\u0753\n\u0080\3\u0080\7\u0080\u0756\n"+
+		"\u0080\f\u0080\16\u0080\u0759\13\u0080\3\u0081\7\u0081\u075c\n\u0081\f"+
+		"\u0081\16\u0081\u075f\13\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081"+
+		"\3\u0081\5\u0081\u0767\n\u0081\3\u0081\7\u0081\u076a\n\u0081\f\u0081\16"+
+		"\u0081\u076d\13\u0081\3\u0082\3\u0082\5\u0082\u0771\n\u0082\3\u0082\3"+
+		"\u0082\3\u0082\3\u0082\3\u0082\5\u0082\u0778\n\u0082\3\u0083\5\u0083\u077b"+
+		"\n\u0083\3\u0083\3\u0083\5\u0083\u077f\n\u0083\7\u0083\u0781\n\u0083\f"+
+		"\u0083\16\u0083\u0784\13\u0083\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084"+
+		"\3\u0084\3\u0084\5\u0084\u078d\n\u0084\3\u0085\3\u0085\3\u0086\3\u0086"+
+		"\3\u0087\3\u0087\3\u0088\3\u0088\3\u0089\3\u0089\3\u008a\3\u008a\3\u008b"+
+		"\3\u008b\3\u008b\2\4x\u00a6\u008c\2\4\6\b\n\f\16\20\22\24\26\30\32\34"+
+		"\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082"+
+		"\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a"+
+		"\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2"+
+		"\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca"+
+		"\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2"+
+		"\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa"+
+		"\u00fc\u00fe\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112"+
+		"\u0114\2\33\4\2::TT\4\288||\3\2\u00dd\u00de\4\2aayy\3\2\u00d1\u00d2\4"+
+		"\2\u00ca\u00ca\u00cc\u00cd\3\2Z[\3\2tu\3\2\u00a7\u00a8\3\2\u00ce\u00d0"+
+		"\4\2\u00cc\u00cd\u00d4\u00d4\3\2\u00c0\u00c1\4\2\u00ad\u00ae\u00c6\u00c7"+
+		"\3\2\u00a9\u00ac\6\2\u00af\u00b1\u00b3\u00bb\u00bf\u00bf\u00df\u00df\3"+
+		"\2\u00cc\u00cd\4\2\u00e4\u00e5\u00e7\u00e8\4\288mm\4\2..OO\4\2.\u00a2"+
+		"\u00e3\u00e3\6\2..OOpsxx\3\2\u009b\u00a2\3\2\u008b\u009a\t\2//\62\62@"+
+		"@`allvvyy\13\2//\61\62?@QQ^allvvyy\177\u0081\u088a\2\u0117\3\2\2\2\4\u0128"+
+		"\3\2\2\2\6\u0146\3\2\2\2\b\u0149\3\2\2\2\n\u0150\3\2\2\2\f\u0158\3\2\2"+
+		"\2\16\u0164\3\2\2\2\20\u0166\3\2\2\2\22\u016e\3\2\2\2\24\u017b\3\2\2\2"+
+		"\26\u017d\3\2\2\2\30\u0193\3\2\2\2\32\u0196\3\2\2\2\34\u01ad\3\2\2\2\36"+
+		"\u01d9\3\2\2\2 \u01db\3\2\2\2\"\u01f1\3\2\2\2$\u01f3\3\2\2\2&\u01fb\3"+
+		"\2\2\2(\u0204\3\2\2\2*\u0209\3\2\2\2,\u0211\3\2\2\2.\u021d\3\2\2\2\60"+
+		"\u0221\3\2\2\2\62\u0231\3\2\2\2\64\u0238\3\2\2\2\66\u023e\3\2\2\28\u025b"+
+		"\3\2\2\2:\u025d\3\2\2\2<\u025f\3\2\2\2>\u027f\3\2\2\2@\u0281\3\2\2\2B"+
+		"\u0285\3\2\2\2D\u028a\3\2\2\2F\u028d\3\2\2\2H\u0291\3\2\2\2J\u029b\3\2"+
+		"\2\2L\u02a1\3\2\2\2N\u02b7\3\2\2\2P\u02b9\3\2\2\2R\u02bb\3\2\2\2T\u02dc"+
+		"\3\2\2\2V\u02e2\3\2\2\2X\u02e8\3\2\2\2Z\u02ee\3\2\2\2\\\u02f4\3\2\2\2"+
+		"^\u02f7\3\2\2\2`\u02fd\3\2\2\2b\u0334\3\2\2\2d\u0347\3\2\2\2f\u0357\3"+
+		"\2\2\2h\u035a\3\2\2\2j\u035e\3\2\2\2l\u0362\3\2\2\2n\u036f\3\2\2\2p\u0373"+
+		"\3\2\2\2r\u0387\3\2\2\2t\u038a\3\2\2\2v\u0397\3\2\2\2x\u03b1\3\2\2\2z"+
+		"\u03bb\3\2\2\2|\u03ce\3\2\2\2~\u03d0\3\2\2\2\u0080\u03d4\3\2\2\2\u0082"+
+		"\u041a\3\2\2\2\u0084\u0425\3\2\2\2\u0086\u0429\3\2\2\2\u0088\u042b\3\2"+
+		"\2\2\u008a\u0432\3\2\2\2\u008c\u0440\3\2\2\2\u008e\u0444\3\2\2\2\u0090"+
+		"\u0449\3\2\2\2\u0092\u0451\3\2\2\2\u0094\u0455\3\2\2\2\u0096\u0458\3\2"+
+		"\2\2\u0098\u045c\3\2\2\2\u009a\u0461\3\2\2\2\u009c\u0466\3\2\2\2\u009e"+
+		"\u0473\3\2\2\2\u00a0\u0496\3\2\2\2\u00a2\u0498\3\2\2\2\u00a4\u04a0\3\2"+
+		"\2\2\u00a6\u0501\3\2\2\2\u00a8\u0544\3\2\2\2\u00aa\u0551\3\2\2\2\u00ac"+
+		"\u0586\3\2\2\2\u00ae\u0589\3\2\2\2\u00b0\u0590\3\2\2\2\u00b2\u05b1\3\2"+
+		"\2\2\u00b4\u05b3\3\2\2\2\u00b6\u05c5\3\2\2\2\u00b8\u05d0\3\2\2\2\u00ba"+
+		"\u05d5\3\2\2\2\u00bc\u05d7\3\2\2\2\u00be\u05e1\3\2\2\2\u00c0\u05f8\3\2"+
+		"\2\2\u00c2\u05fa\3\2\2\2\u00c4\u0607\3\2\2\2\u00c6\u0610\3\2\2\2\u00c8"+
+		"\u061c\3\2\2\2\u00ca\u061f\3\2\2\2\u00cc\u064a\3\2\2\2\u00ce\u0653\3\2"+
+		"\2\2\u00d0\u0667\3\2\2\2\u00d2\u067c\3\2\2\2\u00d4\u067e\3\2\2\2\u00d6"+
+		"\u0686\3\2\2\2\u00d8\u06a0\3\2\2\2\u00da\u06a2\3\2\2\2\u00dc\u06c8\3\2"+
+		"\2\2\u00de\u06cf\3\2\2\2\u00e0\u06d5\3\2\2\2\u00e2\u06d7\3\2\2\2\u00e4"+
+		"\u06eb\3\2\2\2\u00e6\u06ed\3\2\2\2\u00e8\u0704\3\2\2\2\u00ea\u0709\3\2"+
+		"\2\2\u00ec\u070b\3\2\2\2\u00ee\u0713\3\2\2\2\u00f0\u0720\3\2\2\2\u00f2"+
+		"\u0722\3\2\2\2\u00f4\u0727\3\2\2\2\u00f6\u072e\3\2\2\2\u00f8\u0731\3\2"+
+		"\2\2\u00fa\u0747\3\2\2\2\u00fc\u074b\3\2\2\2\u00fe\u0752\3\2\2\2\u0100"+
+		"\u075d\3\2\2\2\u0102\u0777\3\2\2\2\u0104\u077a\3\2\2\2\u0106\u078c\3\2"+
+		"\2\2\u0108\u078e\3\2\2\2\u010a\u0790\3\2\2\2\u010c\u0792\3\2\2\2\u010e"+
+		"\u0794\3\2\2\2\u0110\u0796\3\2\2\2\u0112\u0798\3\2\2\2\u0114\u079a\3\2"+
+		"\2\2\u0116\u0118\7\f\2\2\u0117\u0116\3\2\2\2\u0117\u0118\3\2\2\2\u0118"+
+		"\u011d\3\2\2\2\u0119\u011c\5\4\3\2\u011a\u011c\5\n\6\2\u011b\u0119\3\2"+
+		"\2\2\u011b\u011a\3\2\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d"+
+		"\u011e\3\2\2\2\u011e\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0121\7\2"+
+		"\2\3\u0121\3\3\2\2\2\u0122\u0124\5\6\4\2\u0123\u0122\3\2\2\2\u0124\u0125"+
+		"\3\2\2\2\u0125\u0123\3\2\2\2\u0125\u0126\3\2\2\2\u0126\u0129\3\2\2\2\u0127"+
+		"\u0129\5\b\5\2\u0128\u0123\3\2\2\2\u0128\u0127\3\2\2\2\u0129\5\3\2\2\2"+
+		"\u012a\u0147\7\n\2\2\u012b\u0147\7\21\2\2\u012c\u0147\7\b\2\2\u012d\u0147"+
+		"\7\13\2\2\u012e\u0147\7\32\2\2\u012f\u0147\7\22\2\2\u0130\u0147\7\23\2"+
+		"\2\u0131\u0147\7\4\2\2\u0132\u0147\7\24\2\2\u0133\u0147\7\25\2\2\u0134"+
+		"\u0147\7\35\2\2\u0135\u0147\7\26\2\2\u0136\u0147\7!\2\2\u0137\u0147\7"+
+		"\27\2\2\u0138\u0147\7\30\2\2\u0139\u0147\7\36\2\2\u013a\u0147\7\"\2\2"+
+		"\u013b\u0147\7\'\2\2\u013c\u0147\7\7\2\2\u013d\u0147\7%\2\2\u013e\u0142"+
+		"\7\5\2\2\u013f\u0141\7\16\2\2\u0140\u013f\3\2\2\2\u0141\u0144\3\2\2\2"+
+		"\u0142\u0140\3\2\2\2\u0142\u0143\3\2\2\2\u0143\u0145\3\2\2\2\u0144\u0142"+
+		"\3\2\2\2\u0145\u0147\7\17\2\2\u0146\u012a\3\2\2\2\u0146\u012b\3\2\2\2"+
+		"\u0146\u012c\3\2\2\2\u0146\u012d\3\2\2\2\u0146\u012e\3\2\2\2\u0146\u012f"+
+		"\3\2\2\2\u0146\u0130\3\2\2\2\u0146\u0131\3\2\2\2\u0146\u0132\3\2\2\2\u0146"+
+		"\u0133\3\2\2\2\u0146\u0134\3\2\2\2\u0146\u0135\3\2\2\2\u0146\u0136\3\2"+
+		"\2\2\u0146\u0137\3\2\2\2\u0146\u0138\3\2\2\2\u0146\u0139\3\2\2\2\u0146"+
+		"\u013a\3\2\2\2\u0146\u013b\3\2\2\2\u0146\u013c\3\2\2\2\u0146\u013d\3\2"+
+		"\2\2\u0146\u013e\3\2\2\2\u0147\7\3\2\2\2\u0148\u014a\7$\2\2\u0149\u0148"+
+		"\3\2\2\2\u014a\u014b\3\2\2\2\u014b\u0149\3\2\2\2\u014b\u014c\3\2\2\2\u014c"+
+		"\t\3\2\2\2\u014d\u014f\5\f\7\2\u014e\u014d\3\2\2\2\u014f\u0152\3\2\2\2"+
+		"\u0150\u014e\3\2\2\2\u0150\u0151\3\2\2\2\u0151\u0154\3\2\2\2\u0152\u0150"+
+		"\3\2\2\2\u0153\u0155\5\16\b\2\u0154\u0153\3\2\2\2\u0155\u0156\3\2\2\2"+
+		"\u0156\u0154\3\2\2\2\u0156\u0157\3\2\2\2\u0157\13\3\2\2\2\u0158\u0159"+
+		"\7Y\2\2\u0159\u015a\7i\2\2\u015a\u015b\5\u00d0i\2\u015b\u015c\7\u00de"+
+		"\2\2\u015c\r\3\2\2\2\u015d\u0165\58\35\2\u015e\u0165\5\20\t\2\u015f\u0165"+
+		"\5\26\f\2\u0160\u0165\5\32\16\2\u0161\u0165\5\34\17\2\u0162\u0165\5\u009c"+
+		"O\2\u0163\u0165\5\u009eP\2\u0164\u015d\3\2\2\2\u0164\u015e\3\2\2\2\u0164"+
+		"\u015f\3\2\2\2\u0164\u0160\3\2\2\2\u0164\u0161\3\2\2\2\u0164\u0162\3\2"+
+		"\2\2\u0164\u0163\3\2\2\2\u0165\17\3\2\2\2\u0166\u0168\7\u0082\2\2\u0167"+
+		"\u0169\t\2\2\2\u0168\u0167\3\2\2\2\u0168\u0169\3\2\2\2\u0169\u016a\3\2"+
+		"\2\2\u016a\u016b\5\22\n\2\u016b\u016c\7\u00de\2\2\u016c\21\3\2\2\2\u016d"+
+		"\u016f\7\u00c4\2\2\u016e\u016d\3\2\2\2\u016e\u016f\3\2\2\2\u016f\u0170"+
+		"\3\2\2\2\u0170\u0178\5\24\13\2\u0171\u0173\7\u00dc\2\2\u0172\u0174\7\u00c4"+
+		"\2\2\u0173\u0172\3\2\2\2\u0173\u0174\3\2\2\2\u0174\u0175\3\2\2\2\u0175"+
+		"\u0177\5\24\13\2\u0176\u0171\3\2\2\2\u0177\u017a\3\2\2\2\u0178\u0176\3"+
+		"\2\2\2\u0178\u0179\3\2\2\2\u0179\23\3\2\2\2\u017a\u0178\3\2\2\2\u017b"+
+		"\u017c\5\u00d0i\2\u017c\25\3\2\2\2\u017d\u018c\7i\2\2\u017e\u0180\5\u00d0"+
+		"i\2\u017f\u017e\3\2\2\2\u017f\u0180\3\2\2\2\u0180\u0181\3\2\2\2\u0181"+
+		"\u0185\7\u00da\2\2\u0182\u0184\5\30\r\2\u0183\u0182\3\2\2\2\u0184\u0187"+
+		"\3\2\2\2\u0185\u0183\3\2\2\2\u0185\u0186\3\2\2\2\u0186\u0188\3\2\2\2\u0187"+
+		"\u0185\3\2\2\2\u0188\u018d\7\u00db\2\2\u0189\u018a\5\u00d0i\2\u018a\u018b"+
+		"\7\u00de\2\2\u018b\u018d\3\2\2\2\u018c\u017f\3\2\2\2\u018c\u0189\3\2\2"+
+		"\2\u018d\27\3\2\2\2\u018e\u0194\58\35\2\u018f\u0194\5\20\t\2\u0190\u0194"+
+		"\5\32\16\2\u0191\u0194\5\34\17\2\u0192\u0194\5\u009cO\2\u0193\u018e\3"+
+		"\2\2\2\u0193\u018f\3\2\2\2\u0193\u0190\3\2\2\2\u0193\u0191\3\2\2\2\u0193"+
+		"\u0192\3\2\2\2\u0194\31\3\2\2\2\u0195\u0197\5.\30\2\u0196\u0195\3\2\2"+
+		"\2\u0196\u0197\3\2\2\2\u0197\u0198\3\2\2\2\u0198\u019a\7T\2\2\u0199\u019b"+
+		"\7\u00c8\2\2\u019a\u0199\3\2\2\2\u019a\u019b\3\2\2\2\u019b\u019c\3\2\2"+
+		"\2\u019c\u019e\5\u010a\u0086\2\u019d\u019f\5\"\22\2\u019e\u019d\3\2\2"+
+		"\2\u019e\u019f\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a1\7\u00d6\2\2\u01a1"+
+		"\u01a2\5t;\2\u01a2\u01a8\7\u00d7\2\2\u01a3\u01a5\7\u00dd\2\2\u01a4\u01a6"+
+		"\7\u00d5\2\2\u01a5\u01a4\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\u01a7\3\2\2"+
+		"\2\u01a7\u01a9\5x=\2\u01a8\u01a3\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01aa"+
+		"\3\2\2\2\u01aa\u01ab\5<\37\2\u01ab\33\3\2\2\2\u01ac\u01ae\5.\30\2\u01ad"+
+		"\u01ac\3\2\2\2\u01ad\u01ae\3\2\2\2\u01ae\u01b0\3\2\2\2\u01af\u01b1\7p"+
+		"\2\2\u01b0\u01af\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1\u01b3\3\2\2\2\u01b2"+
+		"\u01b4\5\u0108\u0085\2\u01b3\u01b2\3\2\2\2\u01b3\u01b4\3\2\2\2\u01b4\u01b6"+
+		"\3\2\2\2\u01b5\u01b7\7n\2\2\u01b6\u01b5\3\2\2\2\u01b6\u01b7\3\2\2\2\u01b7"+
+		"\u01ce\3\2\2\2\u01b8\u01b9\5\36\20\2\u01b9\u01bb\5\u010a\u0086\2\u01ba"+
+		"\u01bc\5\"\22\2\u01bb\u01ba\3\2\2\2\u01bb\u01bc\3\2\2\2\u01bc\u01bf\3"+
+		"\2\2\2\u01bd\u01be\7N\2\2\u01be\u01c0\5\u00c6d\2\u01bf\u01bd\3\2\2\2\u01bf"+
+		"\u01c0\3\2\2\2\u01c0\u01c3\3\2\2\2\u01c1\u01c2\7X\2\2\u01c2\u01c4\5 \21"+
+		"\2\u01c3\u01c1\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4\u01cf\3\2\2\2\u01c5\u01c6"+
+		"\7b\2\2\u01c6\u01c8\5\u010a\u0086\2\u01c7\u01c9\5\"\22\2\u01c8\u01c7\3"+
+		"\2\2\2\u01c8\u01c9\3\2\2\2\u01c9\u01cc\3\2\2\2\u01ca\u01cb\7N\2\2\u01cb"+
+		"\u01cd\5 \21\2\u01cc\u01ca\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01cf\3\2"+
+		"\2\2\u01ce\u01b8\3\2\2\2\u01ce\u01c5\3\2\2\2\u01cf\u01d0\3\2\2\2\u01d0"+
+		"\u01d4\7\u00da\2\2\u01d1\u01d3\5\u0082B\2\u01d2\u01d1\3\2\2\2\u01d3\u01d6"+
+		"\3\2\2\2\u01d4\u01d2\3\2\2\2\u01d4\u01d5\3\2\2\2\u01d5\u01d7\3\2\2\2\u01d6"+
+		"\u01d4\3\2\2\2\u01d7\u01d8\7\u00db\2\2\u01d8\35\3\2\2\2\u01d9\u01da\t"+
+		"\3\2\2\u01da\37\3\2\2\2\u01db\u01e0\5\u00c6d\2\u01dc\u01dd\7\u00dc\2\2"+
+		"\u01dd\u01df\5\u00c6d\2\u01de\u01dc\3\2\2\2\u01df\u01e2\3\2\2\2\u01e0"+
+		"\u01de\3\2\2\2\u01e0\u01e1\3\2\2\2\u01e1!\3\2\2\2\u01e2\u01e0\3\2\2\2"+
+		"\u01e3\u01e4\7\u00a4\2\2\u01e4\u01e5\5$\23\2\u01e5\u01e6\7\u00a5\2\2\u01e6"+
+		"\u01f2\3\2\2\2\u01e7\u01e8\7\u00a4\2\2\u01e8\u01e9\5&\24\2\u01e9\u01ea"+
+		"\7\u00a5\2\2\u01ea\u01f2\3\2\2\2\u01eb\u01ec\7\u00a4\2\2\u01ec\u01ed\5"+
+		"$\23\2\u01ed\u01ee\7\u00dc\2\2\u01ee\u01ef\5&\24\2\u01ef\u01f0\7\u00a5"+
+		"\2\2\u01f0\u01f2\3\2\2\2\u01f1\u01e3\3\2\2\2\u01f1\u01e7\3\2\2\2\u01f1"+
+		"\u01eb\3\2\2\2\u01f2#\3\2\2\2\u01f3\u01f8\5(\25\2\u01f4\u01f5\7\u00dc"+
+		"\2\2\u01f5\u01f7\5(\25\2\u01f6\u01f4\3\2\2\2\u01f7\u01fa\3\2\2\2\u01f8"+
+		"\u01f6\3\2\2\2\u01f8\u01f9\3\2\2\2\u01f9%\3\2\2\2\u01fa\u01f8\3\2\2\2"+
+		"\u01fb\u0200\5*\26\2\u01fc\u01fd\7\u00dc\2\2\u01fd\u01ff\5*\26\2\u01fe"+
+		"\u01fc\3\2\2\2\u01ff\u0202\3\2\2\2\u0200\u01fe\3\2\2\2\u0200\u0201\3\2"+
+		"\2\2\u0201\'\3\2\2\2\u0202\u0200\3\2\2\2\u0203\u0205\5.\30\2\u0204\u0203"+
+		"\3\2\2\2\u0204\u0205\3\2\2\2\u0205\u0206\3\2\2\2\u0206\u0207\5\u010a\u0086"+
+		"\2\u0207)\3\2\2\2\u0208\u020a\5.\30\2\u0209\u0208\3\2\2\2\u0209\u020a"+
+		"\3\2\2\2\u020a\u020b\3\2\2\2\u020b\u020c\5\u010a\u0086\2\u020c\u020f\7"+
+		"\u00df\2\2\u020d\u0210\5\u00c6d\2\u020e\u0210\5\u0112\u008a\2\u020f\u020d"+
+		"\3\2\2\2\u020f\u020e\3\2\2\2\u0210+\3\2\2\2\u0211\u0212\7\u00a4\2\2\u0212"+
+		"\u0217\5\u00c8e\2\u0213\u0214\7\u00dc\2\2\u0214\u0216\5\u00c8e\2\u0215"+
+		"\u0213\3\2\2\2\u0216\u0219\3\2\2\2\u0217\u0215\3\2\2\2\u0217\u0218\3\2"+
+		"\2\2\u0218\u021a\3\2\2\2\u0219\u0217\3\2\2\2\u021a\u021b\7\u00a5\2\2\u021b"+
+		"-\3\2\2\2\u021c\u021e\5\60\31\2\u021d\u021c\3\2\2\2\u021e\u021f\3\2\2"+
+		"\2\u021f\u021d\3\2\2\2\u021f\u0220\3\2\2\2\u0220/\3\2\2\2\u0221\u0225"+
+		"\7-\2\2\u0222\u0223\5\u010a\u0086\2\u0223\u0224\7\u00dd\2\2\u0224\u0226"+
+		"\3\2\2\2\u0225\u0222\3\2\2\2\u0225\u0226\3\2\2\2\u0226\u0227\3\2\2\2\u0227"+
+		"\u022c\5\62\32\2\u0228\u0229\7\u00dc\2\2\u0229\u022b\5\62\32\2\u022a\u0228"+
+		"\3\2\2\2\u022b\u022e\3\2\2\2\u022c\u022a\3\2\2\2\u022c\u022d\3\2\2\2\u022d"+
+		"\u022f\3\2\2\2\u022e\u022c\3\2\2\2\u022f\u0230\7\u00d9\2\2\u0230\61\3"+
+		"\2\2\2\u0231\u0233\5\u00ceh\2\u0232\u0234\5\u00d6l\2\u0233\u0232\3\2\2"+
+		"\2\u0233\u0234\3\2\2\2\u0234\63\3\2\2\2\u0235\u0237\5\66\34\2\u0236\u0235"+
+		"\3\2\2\2\u0237\u023a\3\2\2\2\u0238\u0236\3\2\2\2\u0238\u0239\3\2\2\2\u0239"+
+		"\65\3\2\2\2\u023a\u0238\3\2\2\2\u023b\u023f\58\35\2\u023c\u023f\5\32\16"+
+		"\2\u023d\u023f\5\34\17\2\u023e\u023b\3\2\2\2\u023e\u023c\3\2\2\2\u023e"+
+		"\u023d\3\2\2\2\u023f\67\3\2\2\2\u0240\u0241\5\u010a\u0086\2\u0241\u0242"+
+		"\7\u00dd\2\2\u0242\u025c\3\2\2\2\u0243\u025c\5<\37\2\u0244\u025c\5> \2"+
+		"\u0245\u025c\5H%\2\u0246\u025c\5J&\2\u0247\u025c\5L\'\2\u0248\u025c\5"+
+		"R*\2\u0249\u025c\5V,\2\u024a\u025c\5X-\2\u024b\u025c\5Z.\2\u024c\u024d"+
+		"\5\u00bc_\2\u024d\u024e\7\u00de\2\2\u024e\u025c\3\2\2\2\u024f\u025c\5"+
+		"z>\2\u0250\u025c\5\u0080A\2\u0251\u025c\5~@\2\u0252\u025c\5\\/\2\u0253"+
+		"\u025c\5^\60\2\u0254\u025c\5`\61\2\u0255\u025c\5b\62\2\u0256\u025c\5h"+
+		"\65\2\u0257\u025c\5j\66\2\u0258\u025c\5l\67\2\u0259\u025c\5:\36\2\u025a"+
+		"\u025c\5n8\2\u025b\u0240\3\2\2\2\u025b\u0243\3\2\2\2\u025b\u0244\3\2\2"+
+		"\2\u025b\u0245\3\2\2\2\u025b\u0246\3\2\2\2\u025b\u0247\3\2\2\2\u025b\u0248"+
+		"\3\2\2\2\u025b\u0249\3\2\2\2\u025b\u024a\3\2\2\2\u025b\u024b\3\2\2\2\u025b"+
+		"\u024c\3\2\2\2\u025b\u024f\3\2\2\2\u025b\u0250\3\2\2\2\u025b\u0251\3\2"+
+		"\2\2\u025b\u0252\3\2\2\2\u025b\u0253\3\2\2\2\u025b\u0254\3\2\2\2\u025b"+
+		"\u0255\3\2\2\2\u025b\u0256\3\2\2\2\u025b\u0257\3\2\2\2\u025b\u0258\3\2"+
+		"\2\2\u025b\u0259\3\2\2\2\u025b\u025a\3\2\2\2\u025c9\3\2\2\2\u025d\u025e"+
+		"\7\u00de\2\2\u025e;\3\2\2\2\u025f\u0260\7\u00da\2\2\u0260\u0261\5\64\33"+
+		"\2\u0261\u0262\7\u00db\2\2\u0262=\3\2\2\2\u0263\u0264\7W\2\2\u0264\u0265"+
+		"\5\u00a4S\2\u0265\u0269\58\35\2\u0266\u0268\5@!\2\u0267\u0266\3\2\2\2"+
+		"\u0268\u026b\3\2\2\2\u0269\u0267\3\2\2\2\u0269\u026a\3\2\2\2\u026a\u026d"+
+		"\3\2\2\2\u026b\u0269\3\2\2\2\u026c\u026e\5D#\2\u026d\u026c\3\2\2\2\u026d"+
+		"\u026e\3\2\2\2\u026e\u0280\3\2\2\2\u026f\u0270\7W\2\2\u0270\u0271\5\u00a4"+
+		"S\2\u0271\u0272\7\u00dd\2\2\u0272\u0276\5\64\33\2\u0273\u0275\5B\"\2\u0274"+
+		"\u0273\3\2\2\2\u0275\u0278\3\2\2\2\u0276\u0274\3\2\2\2\u0276\u0277\3\2"+
+		"\2\2\u0277\u027a\3\2\2\2\u0278\u0276\3\2\2\2\u0279\u027b\5F$\2\u027a\u0279"+
+		"\3\2\2\2\u027a\u027b\3\2\2\2\u027b\u027c\3\2\2\2\u027c\u027d\7I\2\2\u027d"+
+		"\u027e\7\u00de\2\2\u027e\u0280\3\2\2\2\u027f\u0263\3\2\2\2\u027f\u026f"+
+		"\3\2\2\2\u0280?\3\2\2\2\u0281\u0282\7C\2\2\u0282\u0283\5\u00a4S\2\u0283"+
+		"\u0284\58\35\2\u0284A\3\2\2\2\u0285\u0286\7C\2\2\u0286\u0287\5\u00a4S"+
+		"\2\u0287\u0288\7\u00dd\2\2\u0288\u0289\5\64\33\2\u0289C\3\2\2\2\u028a"+
+		"\u028b\7B\2\2\u028b\u028c\58\35\2\u028cE\3\2\2\2\u028d\u028e\7B\2\2\u028e"+
+		"\u028f\7\u00dd\2\2\u028f\u0290\5\64\33\2\u0290G\3\2\2\2\u0291\u0292\7"+
+		"\u0084\2\2\u0292\u0299\5\u00a4S\2\u0293\u029a\58\35\2\u0294\u0295\7\u00dd"+
+		"\2\2\u0295\u0296\5\64\33\2\u0296\u0297\7K\2\2\u0297\u0298\7\u00de\2\2"+
+		"\u0298\u029a\3\2\2\2\u0299\u0293\3\2\2\2\u0299\u0294\3\2\2\2\u029aI\3"+
+		"\2\2\2\u029b\u029c\7>\2\2\u029c\u029d\58\35\2\u029d\u029e\7\u0084\2\2"+
+		"\u029e\u029f\5\u00a4S\2\u029f\u02a0\7\u00de\2\2\u02a0K\3\2\2\2\u02a1\u02a2"+
+		"\7R\2\2\u02a2\u02a4\7\u00d6\2\2\u02a3\u02a5\5N(\2\u02a4\u02a3\3\2\2\2"+
+		"\u02a4\u02a5\3\2\2\2\u02a5\u02a6\3\2\2\2\u02a6\u02a8\7\u00de\2\2\u02a7"+
+		"\u02a9\5\u00a2R\2\u02a8\u02a7\3\2\2\2\u02a8\u02a9\3\2\2\2\u02a9\u02aa"+
+		"\3\2\2\2\u02aa\u02ac\7\u00de\2\2\u02ab\u02ad\5P)\2\u02ac\u02ab\3\2\2\2"+
+		"\u02ac\u02ad\3\2\2\2\u02ad\u02ae\3\2\2\2\u02ae\u02b5\7\u00d7\2\2\u02af"+
+		"\u02b6\58\35\2\u02b0\u02b1\7\u00dd\2\2\u02b1\u02b2\5\64\33\2\u02b2\u02b3"+
+		"\7G\2\2\u02b3\u02b4\7\u00de\2\2\u02b4\u02b6\3\2\2\2\u02b5\u02af\3\2\2"+
+		"\2\u02b5\u02b0\3\2\2\2\u02b6M\3\2\2\2\u02b7\u02b8\5\u00a2R\2\u02b8O\3"+
+		"\2\2\2\u02b9\u02ba\5\u00a2R\2\u02baQ\3\2\2\2\u02bb\u02bc\7z\2\2\u02bc"+
+		"\u02d4\5\u00a4S\2\u02bd\u02bf\7\u00da\2\2\u02be\u02c0\7\u00de\2\2\u02bf"+
+		"\u02be\3\2\2\2\u02bf\u02c0\3\2\2\2\u02c0\u02c4\3\2\2\2\u02c1\u02c3\5T"+
+		"+\2\u02c2\u02c1\3\2\2\2\u02c3\u02c6\3\2\2\2\u02c4\u02c2\3\2\2\2\u02c4"+
+		"\u02c5\3\2\2\2\u02c5\u02c7\3\2\2\2\u02c6\u02c4\3\2\2\2\u02c7\u02d5\7\u00db"+
+		"\2\2\u02c8\u02ca\7\u00dd\2\2\u02c9\u02cb\7\u00de\2\2\u02ca\u02c9\3\2\2"+
+		"\2\u02ca\u02cb\3\2\2\2\u02cb\u02cf\3\2\2\2\u02cc\u02ce\5T+\2\u02cd\u02cc"+
+		"\3\2\2\2\u02ce\u02d1\3\2\2\2\u02cf\u02cd\3\2\2\2\u02cf\u02d0\3\2\2\2\u02d0"+
+		"\u02d2\3\2\2\2\u02d1\u02cf\3\2\2\2\u02d2\u02d3\7J\2\2\u02d3\u02d5\7\u00de"+
+		"\2\2\u02d4\u02bd\3\2\2\2\u02d4\u02c8\3\2\2\2\u02d5S\3\2\2\2\u02d6\u02d7"+
+		"\7\66\2\2\u02d7\u02da\5\u00a6T\2\u02d8\u02da\7=\2\2\u02d9\u02d6\3\2\2"+
+		"\2\u02d9\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\t\4\2\2\u02dc\u02d9"+
+		"\3\2\2\2\u02dd\u02de\3\2\2\2\u02de\u02dc\3\2\2\2\u02de\u02df\3\2\2\2\u02df"+
+		"\u02e0\3\2\2\2\u02e0\u02e1\5\64\33\2\u02e1U\3\2\2\2\u02e2\u02e4\7\64\2"+
+		"\2\u02e3\u02e5\5\u00a6T\2\u02e4\u02e3\3\2\2\2\u02e4\u02e5\3\2\2\2\u02e5"+
+		"\u02e6\3\2\2\2\u02e6\u02e7\7\u00de\2\2\u02e7W\3\2\2\2\u02e8\u02ea\7;\2"+
+		"\2\u02e9\u02eb\5\u00a6T\2\u02ea\u02e9\3\2\2\2\u02ea\u02eb\3\2\2\2\u02eb"+
+		"\u02ec\3\2\2\2\u02ec\u02ed\7\u00de\2\2\u02edY\3\2\2\2\u02ee\u02f0\7w\2"+
+		"\2\u02ef\u02f1\5\u00a6T\2\u02f0\u02ef\3\2\2\2\u02f0\u02f1\3\2\2\2\u02f1"+
+		"\u02f2\3\2\2\2\u02f2\u02f3\7\u00de\2\2\u02f3[\3\2\2\2\u02f4\u02f5\5\u00a6"+
+		"T\2\u02f5\u02f6\7\u00de\2\2\u02f6]\3\2\2\2\u02f7\u02f8\7\u0081\2\2\u02f8"+
+		"\u02f9\7\u00d6\2\2\u02f9\u02fa\5\u00ecw\2\u02fa\u02fb\7\u00d7\2\2\u02fb"+
+		"\u02fc\7\u00de\2\2\u02fc_\3\2\2\2\u02fd\u032a\7S\2\2\u02fe\u02ff\7\u00d6"+
+		"\2\2\u02ff\u0300\5\u00a6T\2\u0300\u0301\7\60\2\2\u0301\u0302\5\u00acW"+
+		"\2\u0302\u0303\7\u00d7\2\2\u0303\u032b\3\2\2\2\u0304\u0305\7\u00d6\2\2"+
+		"\u0305\u0306\5\u00eex\2\u0306\u0308\7\60\2\2\u0307\u0309\7\u00c8\2\2\u0308"+
+		"\u0307\3\2\2\2\u0308\u0309\3\2\2\2\u0309\u030a\3\2\2\2\u030a\u0310\5\u00a8"+
+		"U\2\u030b\u030d\7\u00a6\2\2\u030c\u030e\7\u00c8\2\2\u030d\u030c\3\2\2"+
+		"\2\u030d\u030e\3\2\2\2\u030e\u030f\3\2\2\2\u030f\u0311\5\u00eex\2\u0310"+
+		"\u030b\3\2\2\2\u0310\u0311\3\2\2\2\u0311\u0312\3\2\2\2\u0312\u0313\7\u00d7"+
+		"\2\2\u0313\u032b\3\2\2\2\u0314\u0315\7\u00d6\2\2\u0315\u0316\5\u00a6T"+
+		"\2\u0316\u0317\7\60\2\2\u0317\u031d\5\u00a8U\2\u0318\u031a\7\u00a6\2\2"+
+		"\u0319\u031b\7\u00c8\2\2\u031a\u0319\3\2\2\2\u031a\u031b\3\2\2\2\u031b"+
+		"\u031c\3\2\2\2\u031c\u031e\5\u00eex\2\u031d\u0318\3\2\2\2\u031d\u031e"+
+		"\3\2\2\2\u031e\u031f\3\2\2\2\u031f\u0320\7\u00d7\2\2\u0320\u032b\3\2\2"+
+		"\2\u0321\u0322\7\u00d6\2\2\u0322\u0323\5\u00eex\2\u0323\u0324\7\60\2\2"+
+		"\u0324\u0325\7d\2\2\u0325\u0326\7\u00d6\2\2\u0326\u0327\5\u0104\u0083"+
+		"\2\u0327\u0328\7\u00d7\2\2\u0328\u0329\7\u00d7\2\2\u0329\u032b\3\2\2\2"+
+		"\u032a\u02fe\3\2\2\2\u032a\u0304\3\2\2\2\u032a\u0314\3\2\2\2\u032a\u0321"+
+		"\3\2\2\2\u032b\u0332\3\2\2\2\u032c\u0333\58\35\2\u032d\u032e\7\u00dd\2"+
+		"\2\u032e\u032f\5\64\33\2\u032f\u0330\7H\2\2\u0330\u0331\7\u00de\2\2\u0331"+
+		"\u0333\3\2\2\2\u0332\u032c\3\2\2\2\u0332\u032d\3\2\2\2\u0333a\3\2\2\2"+
+		"\u0334\u0335\7}\2\2\u0335\u0345\5<\37\2\u0336\u0338\5d\63\2\u0337\u0336"+
+		"\3\2\2\2\u0338\u0339\3\2\2\2\u0339\u0337\3\2\2\2\u0339\u033a\3\2\2\2\u033a"+
+		"\u033c\3\2\2\2\u033b\u033d\5f\64\2\u033c\u033b\3\2\2\2\u033c\u033d\3\2"+
+		"\2\2\u033d\u0346\3\2\2\2\u033e\u0340\5d\63\2\u033f\u033e\3\2\2\2\u0340"+
+		"\u0343\3\2\2\2\u0341\u033f\3\2\2\2\u0341\u0342\3\2\2\2\u0342\u0344\3\2"+
+		"\2\2\u0343\u0341\3\2\2\2\u0344\u0346\5f\64\2\u0345\u0337\3\2\2\2\u0345"+
+		"\u0341\3\2\2\2\u0346c\3\2\2\2\u0347\u0348\7\67\2\2\u0348\u0349\7\u00d6"+
+		"\2\2\u0349\u034e\5\u00c6d\2\u034a\u034b\7\u00c9\2\2\u034b\u034d\5\u00c6"+
+		"d\2\u034c\u034a\3\2\2\2\u034d\u0350\3\2\2\2\u034e\u034c\3\2\2\2\u034e"+
+		"\u034f\3\2\2\2\u034f\u0352\3\2\2\2\u0350\u034e\3\2\2\2\u0351\u0353\7\u00e2"+
+		"\2\2\u0352\u0351\3\2\2\2\u0352\u0353\3\2\2\2\u0353\u0354\3\2\2\2\u0354"+
+		"\u0355\7\u00d7\2\2\u0355\u0356\5<\37\2\u0356e\3\2\2\2\u0357\u0358\7P\2"+
+		"\2\u0358\u0359\5<\37\2\u0359g\3\2\2\2\u035a\u035b\7{\2\2\u035b\u035c\5"+
+		"\u00a6T\2\u035c\u035d\7\u00de\2\2\u035di\3\2\2\2\u035e\u035f\7V\2\2\u035f"+
+		"\u0360\5\u010a\u0086\2\u0360\u0361\7\u00de\2\2\u0361k\3\2\2\2\u0362\u0363"+
+		"\7<\2\2\u0363\u0364\7\u00d6\2\2\u0364\u0365\5p9\2\u0365\u036c\7\u00d7"+
+		"\2\2\u0366\u036d\58\35\2\u0367\u0368\7\u00dd\2\2\u0368\u0369\5\64\33\2"+
+		"\u0369\u036a\7F\2\2\u036a\u036b\7\u00de\2\2\u036b\u036d\3\2\2\2\u036c"+
+		"\u0366\3\2\2\2\u036c\u0367\3\2\2\2\u036dm\3\2\2\2\u036e\u0370\5\4\3\2"+
+		"\u036f\u036e\3\2\2\2\u0370\u0371\3\2\2\2\u0371\u036f\3\2\2\2\u0371\u0372"+
+		"\3\2\2\2\u0372o\3\2\2\2\u0373\u0378\5r:\2\u0374\u0375\7\u00dc\2\2\u0375"+
+		"\u0377\5r:\2\u0376\u0374\3\2\2\2\u0377\u037a\3\2\2\2\u0378\u0376\3\2\2"+
+		"\2\u0378\u0379\3\2\2\2\u0379q\3\2\2\2\u037a\u0378\3\2\2\2\u037b\u037c"+
+		"\7\u0088\2\2\u037c\u037f\7\u00df\2\2\u037d\u0380\5\u00e2r\2\u037e\u0380"+
+		"\7\u00e6\2\2\u037f\u037d\3\2\2\2\u037f\u037e\3\2\2\2\u0380\u0388\3\2\2"+
+		"\2\u0381\u0382\7\u0089\2\2\u0382\u0383\7\u00df\2\2\u0383\u0388\7\u00ea"+
+		"\2\2\u0384\u0385\7\u008a\2\2\u0385\u0386\7\u00df\2\2\u0386\u0388\5\u00e2"+
+		"r\2\u0387\u037b\3\2\2\2\u0387\u0381\3\2\2\2\u0387\u0384\3\2\2\2\u0388"+
+		"s\3\2\2\2\u0389\u038b\5v<\2\u038a\u0389\3\2\2\2\u038a\u038b\3\2\2\2\u038b"+
+		"\u0390\3\2\2\2\u038c\u038d\7\u00dc\2\2\u038d\u038f\5v<\2\u038e\u038c\3"+
+		"\2\2\2\u038f\u0392\3\2\2\2\u0390\u038e\3\2\2\2\u0390\u0391\3\2\2\2\u0391"+
+		"\u0394\3\2\2\2\u0392\u0390\3\2\2\2\u0393\u0395\7\u00dc\2\2\u0394\u0393"+
+		"\3\2\2\2\u0394\u0395\3\2\2\2\u0395u\3\2\2\2\u0396\u0398\5.\30\2\u0397"+
+		"\u0396\3\2\2\2\u0397\u0398\3\2\2\2\u0398\u039c\3\2\2\2\u0399\u039b\5\u010c"+
+		"\u0087\2\u039a\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c"+
+		"\u039d\3\2\2\2\u039d\u03a0\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a1\7\u00d5"+
+		"\2\2\u03a0\u039f\3\2\2\2\u03a0\u03a1\3\2\2\2\u03a1\u03a3\3\2\2\2\u03a2"+
+		"\u03a4\5x=\2\u03a3\u03a2\3\2\2\2\u03a3\u03a4\3\2\2\2\u03a4\u03a6\3\2\2"+
+		"\2\u03a5\u03a7\7\u00c8\2\2\u03a6\u03a5\3\2\2\2\u03a6\u03a7\3\2\2\2\u03a7"+
+		"\u03a9\3\2\2\2\u03a8\u03aa\7\u00c5\2\2\u03a9\u03a8\3\2\2\2\u03a9\u03aa"+
+		"\3\2\2\2\u03aa\u03ab\3\2\2\2\u03ab\u03ac\5\u0098M\2\u03acw\3\2\2\2\u03ad"+
+		"\u03ae\b=\1\2\u03ae\u03b2\5\u00c6d\2\u03af\u03b2\7\65\2\2\u03b0\u03b2"+
+		"\5\u0112\u008a\2\u03b1\u03ad\3\2\2\2\u03b1\u03af\3\2\2\2\u03b1\u03b0\3"+
+		"\2\2\2\u03b2\u03b8\3\2\2\2\u03b3\u03b4\f\3\2\2\u03b4\u03b5\7\u00c9\2\2"+
+		"\u03b5\u03b7\5x=\4\u03b6\u03b3\3\2\2\2\u03b7\u03ba\3\2\2\2\u03b8\u03b6"+
+		"\3\2\2\2\u03b8\u03b9\3\2\2\2\u03b9y\3\2\2\2\u03ba\u03b8\3\2\2\2\u03bb"+
+		"\u03bc\7U\2\2\u03bc\u03c1\5|?\2\u03bd\u03be\7\u00dc\2\2\u03be\u03c0\5"+
+		"|?\2\u03bf\u03bd\3\2\2\2\u03c0\u03c3\3\2\2\2\u03c1\u03bf\3\2\2\2\u03c1"+
+		"\u03c2\3\2\2\2\u03c2\u03c4\3\2\2\2\u03c3\u03c1\3\2\2\2\u03c4\u03c5\7\u00de"+
+		"\2\2\u03c5{\3\2\2\2\u03c6\u03cf\7\u00e2\2\2\u03c7\u03c8\7\u00d3\2\2\u03c8"+
+		"\u03cf\5\u00eex\2\u03c9\u03ca\7\u00d3\2\2\u03ca\u03cb\7\u00da\2\2\u03cb"+
+		"\u03cc\5\u00a6T\2\u03cc\u03cd\7\u00db\2\2\u03cd\u03cf\3\2\2\2\u03ce\u03c6"+
+		"\3\2\2\2\u03ce\u03c7\3\2\2\2\u03ce\u03c9\3\2\2\2\u03cf}\3\2\2\2\u03d0"+
+		"\u03d1\7A\2\2\u03d1\u03d2\5\u00a2R\2\u03d2\u03d3\7\u00de\2\2\u03d3\177"+
+		"\3\2\2\2\u03d4\u03d5\7x\2\2\u03d5\u03da\5\u0098M\2\u03d6\u03d7\7\u00dc"+
+		"\2\2\u03d7\u03d9\5\u0098M\2\u03d8\u03d6\3\2\2\2\u03d9\u03dc\3\2\2\2\u03da"+
+		"\u03d8\3\2\2\2\u03da\u03db\3\2\2\2\u03db\u03dd\3\2\2\2\u03dc\u03da\3\2"+
+		"\2\2\u03dd\u03de\7\u00de\2\2\u03de\u0081\3\2\2\2\u03df\u03e1\5.\30\2\u03e0"+
+		"\u03df\3\2\2\2\u03e0\u03e1\3\2\2\2\u03e1\u0414\3\2\2\2\u03e2\u03e4\5\u0094"+
+		"K\2\u03e3\u03e5\5x=\2\u03e4\u03e3\3\2\2\2\u03e4\u03e5\3\2\2\2\u03e5\u03e6"+
+		"\3\2\2\2\u03e6\u03eb\5\u0098M\2\u03e7\u03e8\7\u00dc\2\2\u03e8\u03ea\5"+
+		"\u0098M\2\u03e9\u03e7\3\2\2\2\u03ea\u03ed\3\2\2\2\u03eb\u03e9\3\2\2\2"+
+		"\u03eb\u03ec\3\2\2\2\u03ec\u03ee\3\2\2\2\u03ed\u03eb\3\2\2\2\u03ee\u03ef"+
+		"\7\u00de\2\2\u03ef\u0415\3\2\2\2\u03f0\u03f2\5\u0096L\2\u03f1\u03f0\3"+
+		"\2\2\2\u03f1\u03f2\3\2\2\2\u03f2\u0412\3\2\2\2\u03f3\u03f5\7:\2\2\u03f4"+
+		"\u03f6\5x=\2\u03f5\u03f4\3\2\2\2\u03f5\u03f6\3\2\2\2\u03f6\u03f7\3\2\2"+
+		"\2\u03f7\u03fc\5\u009aN\2\u03f8\u03f9\7\u00dc\2\2\u03f9\u03fb\5\u009a"+
+		"N\2\u03fa\u03f8\3\2\2\2\u03fb\u03fe\3\2\2\2\u03fc\u03fa\3\2\2\2\u03fc"+
+		"\u03fd\3\2\2\2\u03fd\u03ff\3\2\2\2\u03fe\u03fc\3\2\2\2\u03ff\u0400\7\u00de"+
+		"\2\2\u0400\u0413\3\2\2\2\u0401\u0403\7T\2\2\u0402\u0404\7\u00c8\2\2\u0403"+
+		"\u0402\3\2\2\2\u0403\u0404\3\2\2\2\u0404\u0405\3\2\2\2\u0405\u0407\5\u010a"+
+		"\u0086\2\u0406\u0408\5\"\22\2\u0407\u0406\3\2\2\2\u0407\u0408\3\2\2\2"+
+		"\u0408\u0409\3\2\2\2\u0409\u040a\7\u00d6\2\2\u040a\u040b\5t;\2\u040b\u040e"+
+		"\7\u00d7\2\2\u040c\u040f\5\u008eH\2\u040d\u040f\5\u0090I\2\u040e\u040c"+
+		"\3\2\2\2\u040e\u040d\3\2\2\2\u040e\u040f\3\2\2\2\u040f\u0410\3\2\2\2\u0410"+
+		"\u0411\5\u0092J\2\u0411\u0413\3\2\2\2\u0412\u03f3\3\2\2\2\u0412\u0401"+
+		"\3\2\2\2\u0413\u0415\3\2\2\2\u0414\u03e2\3\2\2\2\u0414\u03f1\3\2\2\2\u0415"+
+		"\u041b\3\2\2\2\u0416\u0417\7\u0082\2\2\u0417\u0418\5\u00d4k\2\u0418\u0419"+
+		"\5\u0084C\2\u0419\u041b\3\2\2\2\u041a\u03e0\3\2\2\2\u041a\u0416\3\2\2"+
+		"\2\u041b\u0083\3\2\2\2\u041c\u0426\7\u00de\2\2\u041d\u0421\7\u00da\2\2"+
+		"\u041e\u0420\5\u0086D\2\u041f\u041e\3\2\2\2\u0420\u0423\3\2\2\2\u0421"+
+		"\u041f\3\2\2\2\u0421\u0422\3\2\2\2\u0422\u0424\3\2\2\2\u0423\u0421\3\2"+
+		"\2\2\u0424\u0426\7\u00db\2\2\u0425\u041c\3\2\2\2\u0425\u041d\3\2\2\2\u0426"+
+		"\u0085\3\2\2\2\u0427\u042a\5\u0088E\2\u0428\u042a\5\u008aF\2\u0429\u0427"+
+		"\3\2\2\2\u0429\u0428\3\2\2\2\u042a\u0087\3\2\2\2\u042b\u042c\5\u00ceh"+
+		"\2\u042c\u042d\7\u00c2\2\2\u042d\u042e\5\u010a\u0086\2\u042e\u042f\7]"+
+		"\2\2\u042f\u0430\5\u00d4k\2\u0430\u0431\7\u00de\2\2\u0431\u0089\3\2\2"+
+		"\2\u0432\u0433\5\u008cG\2\u0433\u0439\7\60\2\2\u0434\u043a\5\u010c\u0087"+
+		"\2\u0435\u0437\5\u010c\u0087\2\u0436\u0435\3\2\2\2\u0436\u0437\3\2\2\2"+
+		"\u0437\u0438\3\2\2\2\u0438\u043a\5\u010a\u0086\2\u0439\u0434\3\2\2\2\u0439"+
+		"\u0436\3\2\2\2\u043a\u043b\3\2\2\2\u043b\u043c\7\u00de\2\2\u043c\u008b"+
+		"\3\2\2\2\u043d\u043e\5\u00ceh\2\u043e\u043f\7\u00c2\2\2\u043f\u0441\3"+
+		"\2\2\2\u0440\u043d\3\2\2\2\u0440\u0441\3\2\2\2\u0441\u0442\3\2\2\2\u0442"+
+		"\u0443\5\u010a\u0086\2\u0443\u008d\3\2\2\2\u0444\u0445\7\u00dd\2\2\u0445"+
+		"\u0447\5\u010a\u0086\2\u0446\u0448\5\u00d6l\2\u0447\u0446\3\2\2\2\u0447"+
+		"\u0448\3\2\2\2\u0448\u008f\3\2\2\2\u0449\u044b\7\u00dd\2\2\u044a\u044c"+
+		"\7\u00d5\2\2\u044b\u044a\3\2\2\2\u044b\u044c\3\2\2\2\u044c\u044d\3\2\2"+
+		"\2\u044d\u044e\5x=\2\u044e\u0091\3\2\2\2\u044f\u0452\7\u00de\2\2\u0450"+
+		"\u0452\5<\37\2\u0451\u044f\3\2\2\2\u0451\u0450\3\2\2\2\u0452\u0093\3\2"+
+		"\2\2\u0453\u0456\5\u0096L\2\u0454\u0456\7\u0083\2\2\u0455\u0453\3\2\2"+
+		"\2\u0455\u0454\3\2\2\2\u0456\u0095\3\2\2\2\u0457\u0459\5\u010c\u0087\2"+
+		"\u0458\u0457\3\2\2\2\u0459\u045a\3\2\2\2\u045a\u0458\3\2\2\2\u045a\u045b"+
+		"\3\2\2\2\u045b\u0097\3\2\2\2\u045c\u045f\7\u00e2\2\2\u045d\u045e\7\u00df"+
+		"\2\2\u045e\u0460\5\u00dco\2\u045f\u045d\3\2\2\2\u045f\u0460\3\2\2\2\u0460"+
+		"\u0099\3\2\2\2\u0461\u0462\5\u010a\u0086\2\u0462\u0463\7\u00df\2\2\u0463"+
+		"\u0464\5\u00dco\2\u0464\u009b\3\2\2\2\u0465\u0467\5.\30\2\u0466\u0465"+
+		"\3\2\2\2\u0466\u0467\3\2\2\2\u0467\u0468\3\2\2\2\u0468\u0469\7:\2\2\u0469"+
+		"\u046e\5\u009aN\2\u046a\u046b\7\u00dc\2\2\u046b\u046d\5\u009aN\2\u046c"+
+		"\u046a\3\2\2\2\u046d\u0470\3\2\2\2\u046e\u046c\3\2\2\2\u046e\u046f\3\2"+
+		"\2\2\u046f\u0471\3\2\2\2\u0470\u046e\3\2\2\2\u0471\u0472\7\u00de\2\2\u0472"+
+		"\u009d\3\2\2\2\u0473\u0474\7E\2\2\u0474\u0477\5\u010a\u0086\2\u0475\u0476"+
+		"\7\u00dd\2\2\u0476\u0478\t\5\2\2\u0477\u0475\3\2\2\2\u0477\u0478\3\2\2"+
+		"\2\u0478\u047b\3\2\2\2\u0479\u047a\7X\2\2\u047a\u047c\5 \21\2\u047b\u0479"+
+		"\3\2\2\2\u047b\u047c\3\2\2\2\u047c\u047d\3\2\2\2\u047d\u0481\7\u00da\2"+
+		"\2\u047e\u0480\5\u00a0Q\2\u047f\u047e\3\2\2\2\u0480\u0483\3\2\2\2\u0481"+
+		"\u047f\3\2\2\2\u0481\u0482\3\2\2\2\u0482\u0484\3\2\2\2\u0483\u0481\3\2"+
+		"\2\2\u0484\u0485\7\u00db\2\2\u0485\u009f\3\2\2\2\u0486\u0487\7\66\2\2"+
+		"\u0487\u048a\5\u010a\u0086\2\u0488\u0489\7\u00df\2\2\u0489\u048b\5\u00a6"+
+		"T\2\u048a\u0488\3\2\2\2\u048a\u048b\3\2\2\2\u048b\u048c\3\2\2\2\u048c"+
+		"\u048d\7\u00de\2\2\u048d\u0497\3\2\2\2\u048e\u0490\5\u0096L\2\u048f\u048e"+
+		"\3\2\2\2\u048f\u0490\3\2\2\2\u0490\u0491\3\2\2\2\u0491\u0497\5\32\16\2"+
+		"\u0492\u0493\7\u0082\2\2\u0493\u0494\5\u00d4k\2\u0494\u0495\5\u0084C\2"+
+		"\u0495\u0497\3\2\2\2\u0496\u0486\3\2\2\2\u0496\u048f\3\2\2\2\u0496\u0492"+
+		"\3\2\2\2\u0497\u00a1\3\2\2\2\u0498\u049d\5\u00a6T\2\u0499\u049a\7\u00dc"+
+		"\2\2\u049a\u049c\5\u00a6T\2\u049b\u0499\3\2\2\2\u049c\u049f\3\2\2\2\u049d"+
+		"\u049b\3\2\2\2\u049d\u049e\3\2\2\2\u049e\u00a3\3\2\2\2\u049f\u049d\3\2"+
+		"\2\2\u04a0\u04a3\7\u00d6\2\2\u04a1\u04a4\5\u00a6T\2\u04a2\u04a4\5\u00bc"+
+		"_\2\u04a3\u04a1\3\2\2\2\u04a3\u04a2\3\2\2\2\u04a4\u04a5\3\2\2\2\u04a5"+
+		"\u04a6\7\u00d7\2\2\u04a6\u00a5\3\2\2\2\u04a7\u04a8\bT\1\2\u04a8\u04a9"+
+		"\79\2\2\u04a9\u0502\5\u00a6T\62\u04aa\u04ab\7\u00d6\2\2\u04ab\u04ac\5"+
+		"\u0114\u008b\2\u04ac\u04ad\7\u00d7\2\2\u04ad\u04ae\5\u00a6T/\u04ae\u0502"+
+		"\3\2\2\2\u04af\u04b0\t\6\2\2\u04b0\u0502\5\u00a6T.\u04b1\u04b2\t\7\2\2"+
+		"\u04b2\u0502\5\u00a6T-\u04b3\u04b4\7o\2\2\u04b4\u0502\5\u00a6T*\u04b5"+
+		"\u04b6\7d\2\2\u04b6\u04b7\7\u00d6\2\2\u04b7\u04b8\5\u0104\u0083\2\u04b8"+
+		"\u04b9\7\u00d7\2\2\u04b9\u04ba\7\u00df\2\2\u04ba\u04bb\5\u00a6T!\u04bb"+
+		"\u0502\3\2\2\2\u04bc\u04bd\t\b\2\2\u04bd\u0502\5\u00a6T\34\u04be\u04bf"+
+		"\t\t\2\2\u04bf\u0502\5\u00a6T\33\u04c0\u04c1\7{\2\2\u04c1\u0502\5\u00a6"+
+		"T\t\u04c2\u04c3\5\u00acW\2\u04c3\u04c4\7\u00df\2\2\u04c4\u04c5\5\u00a6"+
+		"T\b\u04c5\u0502\3\2\2\2\u04c6\u04c7\5\u00a8U\2\u04c7\u04c9\5\u00ba^\2"+
+		"\u04c8\u04ca\5.\30\2\u04c9\u04c8\3\2\2\2\u04c9\u04ca\3\2\2\2\u04ca\u04cb"+
+		"\3\2\2\2\u04cb\u04cc\5\u00a6T\7\u04cc\u0502\3\2\2\2\u04cd\u0502\5\u00b8"+
+		"]\2\u04ce\u04cf\5\u00e6t\2\u04cf\u04d0\7\u00d8\2\2\u04d0\u04d1\5\u00a6"+
+		"T\2\u04d1\u04d2\7\u00d9\2\2\u04d2\u0502\3\2\2\2\u04d3\u04d4\t\n\2\2\u04d4"+
+		"\u0502\5\u00eex\2\u04d5\u04d6\5\u00eex\2\u04d6\u04d7\t\n\2\2\u04d7\u0502"+
+		"\3\2\2\2\u04d8\u0502\5\u00aaV\2\u04d9\u0502\5\u00eex\2\u04da\u0502\5\u00de"+
+		"p\2\u04db\u0502\5\u00e8u\2\u04dc\u0502\7\u00e3\2\2\u04dd\u0502\7\u00e9"+
+		"\2\2\u04de\u0502\5\u00a4S\2\u04df\u0502\7\u0085\2\2\u04e0\u04e1\7c\2\2"+
+		"\u04e1\u04e2\7\u00d6\2\2\u04e2\u04e3\5\u00ecw\2\u04e3\u04e4\7\u00d7\2"+
+		"\2\u04e4\u0502\3\2\2\2\u04e5\u04e6\7D\2\2\u04e6\u04e7\7\u00d6\2\2\u04e7"+
+		"\u04e8\5\u00eex\2\u04e8\u04e9\7\u00d7\2\2\u04e9\u0502\3\2\2\2\u04ea\u04eb"+
+		"\7L\2\2\u04eb\u04ec\7\u00d6\2\2\u04ec\u04ed\5\u00a6T\2\u04ed\u04ee\7\u00d7"+
+		"\2\2\u04ee\u0502\3\2\2\2\u04ef\u04f3\7M\2\2\u04f0\u04f1\7\u00d6\2\2\u04f1"+
+		"\u04f4\7\u00d7\2\2\u04f2\u04f4\5\u00a4S\2\u04f3\u04f0\3\2\2\2\u04f3\u04f2"+
+		"\3\2\2\2\u04f3\u04f4\3\2\2\2\u04f4\u0502\3\2\2\2\u04f5\u0502\5\u00b2Z"+
+		"\2\u04f6\u0502\5\u00b4[\2\u04f7\u04f8\5\u00a8U\2\u04f8\u04fa\7\u00df\2"+
+		"\2\u04f9\u04fb\5.\30\2\u04fa\u04f9\3\2\2\2\u04fa\u04fb\3\2\2\2\u04fb\u04fc"+
+		"\3\2\2\2\u04fc\u04ff\7\u00c8\2\2\u04fd\u0500\5\u00eex\2\u04fe\u0500\5"+
+		"\u00b8]\2\u04ff\u04fd\3\2\2\2\u04ff\u04fe\3\2\2\2\u0500\u0502\3\2\2\2"+
+		"\u0501\u04a7\3\2\2\2\u0501\u04aa\3\2\2\2\u0501\u04af\3\2\2\2\u0501\u04b1"+
+		"\3\2\2\2\u0501\u04b3\3\2\2\2\u0501\u04b5\3\2\2\2\u0501\u04bc\3\2\2\2\u0501"+
+		"\u04be\3\2\2\2\u0501\u04c0\3\2\2\2\u0501\u04c2\3\2\2\2\u0501\u04c6\3\2"+
+		"\2\2\u0501\u04cd\3\2\2\2\u0501\u04ce\3\2\2\2\u0501\u04d3\3\2\2\2\u0501"+
+		"\u04d5\3\2\2\2\u0501\u04d8\3\2\2\2\u0501\u04d9\3\2\2\2\u0501\u04da\3\2"+
+		"\2\2\u0501\u04db\3\2\2\2\u0501\u04dc\3\2\2\2\u0501\u04dd\3\2\2\2\u0501"+
+		"\u04de\3\2\2\2\u0501\u04df\3\2\2\2\u0501\u04e0\3\2\2\2\u0501\u04e5\3\2"+
+		"\2\2\u0501\u04ea\3\2\2\2\u0501\u04ef\3\2\2\2\u0501\u04f5\3\2\2\2\u0501"+
+		"\u04f6\3\2\2\2\u0501\u04f7\3\2\2\2\u0502\u053f\3\2\2\2\u0503\u0504\f\30"+
+		"\2\2\u0504\u0505\7\u00b2\2\2\u0505\u053e\5\u00a6T\30\u0506\u0507\f\26"+
+		"\2\2\u0507\u0508\t\13\2\2\u0508\u053e\5\u00a6T\27\u0509\u050a\f\25\2\2"+
+		"\u050a\u050b\t\f\2\2\u050b\u053e\5\u00a6T\26\u050c\u050d\f\24\2\2\u050d"+
+		"\u050e\t\r\2\2\u050e\u053e\5\u00a6T\25\u050f\u0510\f\23\2\2\u0510\u0511"+
+		"\t\16\2\2\u0511\u053e\5\u00a6T\24\u0512\u0513\f\22\2\2\u0513\u0514\t\17"+
+		"\2\2\u0514\u053e\5\u00a6T\23\u0515\u0516\f\21\2\2\u0516\u0517\7\u00c8"+
+		"\2\2\u0517\u053e\5\u00a6T\22\u0518\u0519\f\20\2\2\u0519\u051a\7\u00cb"+
+		"\2\2\u051a\u053e\5\u00a6T\21\u051b\u051c\f\17\2\2\u051c\u051d\7\u00c9"+
+		"\2\2\u051d\u053e\5\u00a6T\20\u051e\u051f\f\16\2\2\u051f\u0520\7\u00bd"+
+		"\2\2\u0520\u053e\5\u00a6T\17\u0521\u0522\f\r\2\2\u0522\u0523\7\u00bc\2"+
+		"\2\u0523\u053e\5\u00a6T\16\u0524\u0525\f\f\2\2\u0525\u0527\7\u00d5\2\2"+
+		"\u0526\u0528\5\u00a6T\2\u0527\u0526\3\2\2\2\u0527\u0528\3\2\2\2\u0528"+
+		"\u0529\3\2\2\2\u0529\u052a\7\u00dd\2\2\u052a\u053e\5\u00a6T\r\u052b\u052c"+
+		"\f\13\2\2\u052c\u052d\7\u00be\2\2\u052d\u053e\5\u00a6T\f\u052e\u052f\f"+
+		"\n\2\2\u052f\u0530\7\u00a3\2\2\u0530\u053e\5\u00a6T\13\u0531\u0532\f\5"+
+		"\2\2\u0532\u0533\7e\2\2\u0533\u053e\5\u00a6T\6\u0534\u0535\f\4\2\2\u0535"+
+		"\u0536\7g\2\2\u0536\u053e\5\u00a6T\5\u0537\u0538\f\3\2\2\u0538\u0539\7"+
+		"f\2\2\u0539\u053e\5\u00a6T\4\u053a\u053b\f\27\2\2\u053b\u053c\7\\\2\2"+
+		"\u053c\u053e\5\u00c8e\2\u053d\u0503\3\2\2\2\u053d\u0506\3\2\2\2\u053d"+
+		"\u0509\3\2\2\2\u053d\u050c\3\2\2\2\u053d\u050f\3\2\2\2\u053d\u0512\3\2"+
+		"\2\2\u053d\u0515\3\2\2\2\u053d\u0518\3\2\2\2\u053d\u051b\3\2\2\2\u053d"+
+		"\u051e\3\2\2\2\u053d\u0521\3\2\2\2\u053d\u0524\3\2\2\2\u053d\u052b\3\2"+
+		"\2\2\u053d\u052e\3\2\2\2\u053d\u0531\3\2\2\2\u053d\u0534\3\2\2\2\u053d"+
+		"\u0537\3\2\2\2\u053d\u053a\3\2\2\2\u053e\u0541\3\2\2\2\u053f\u053d\3\2"+
+		"\2\2\u053f\u0540\3\2\2\2\u0540\u00a7\3\2\2\2\u0541\u053f\3\2\2\2\u0542"+
+		"\u0545\5\u00eex\2\u0543\u0545\5\u00aaV\2\u0544\u0542\3\2\2\2\u0544\u0543"+
+		"\3\2\2\2\u0545\u00a9\3\2\2\2\u0546\u0547\7/\2\2\u0547\u0549\7\u00d6\2"+
+		"\2\u0548\u054a\5\u00be`\2\u0549\u0548\3\2\2\2\u0549\u054a\3\2\2\2\u054a"+
+		"\u054b\3\2\2\2\u054b\u0552\7\u00d7\2\2\u054c\u054e\7\u00d8\2\2\u054d\u054f"+
+		"\5\u00be`\2\u054e\u054d\3\2\2\2\u054e\u054f\3\2\2\2\u054f\u0550\3\2\2"+
+		"\2\u0550\u0552\7\u00d9\2\2\u0551\u0546\3\2\2\2\u0551\u054c\3\2\2\2\u0552"+
+		"\u0557\3\2\2\2\u0553\u0554\7\u00d8\2\2\u0554\u0555\5\u00a6T\2\u0555\u0556"+
+		"\7\u00d9\2\2\u0556\u0558\3\2\2\2\u0557\u0553\3\2\2\2\u0557\u0558\3\2\2"+
+		"\2\u0558\u00ab\3\2\2\2\u0559\u055d\7\u00d8\2\2\u055a\u055c\7\u00dc\2\2"+
+		"\u055b\u055a\3\2\2\2\u055c\u055f\3\2\2\2\u055d\u055b\3\2\2\2\u055d\u055e"+
+		"\3\2\2\2\u055e\u0560\3\2\2\2\u055f\u055d\3\2\2\2\u0560\u0569\5\u00aeX"+
+		"\2\u0561\u0563\7\u00dc\2\2\u0562\u0561\3\2\2\2\u0563\u0564\3\2\2\2\u0564"+
+		"\u0562\3\2\2\2\u0564\u0565\3\2\2\2\u0565\u0566\3\2\2\2\u0566\u0568\5\u00ae"+
+		"X\2\u0567\u0562\3\2\2\2\u0568\u056b\3\2\2\2\u0569\u0567\3\2\2\2\u0569"+
+		"\u056a\3\2\2\2\u056a\u056f\3\2\2\2\u056b\u0569\3\2\2\2\u056c\u056e\7\u00dc"+
+		"\2\2\u056d\u056c\3\2\2\2\u056e\u0571\3\2\2\2\u056f\u056d\3\2\2\2\u056f"+
+		"\u0570\3\2\2\2\u0570\u0572\3\2\2\2\u0571\u056f\3\2\2\2\u0572\u0573\7\u00d9"+
+		"\2\2\u0573\u0587\3\2\2\2\u0574\u0575\7\u00d8\2\2\u0575\u057e\5\u00b0Y"+
+		"\2\u0576\u0578\7\u00dc\2\2\u0577\u0576\3\2\2\2\u0578\u0579\3\2\2\2\u0579"+
+		"\u0577\3\2\2\2\u0579\u057a\3\2\2\2\u057a\u057b\3\2\2\2\u057b\u057d\5\u00b0"+
+		"Y\2\u057c\u0577\3\2\2\2\u057d\u0580\3\2\2\2\u057e\u057c\3\2\2\2\u057e"+
+		"\u057f\3\2\2\2\u057f\u0582\3\2\2\2\u0580\u057e\3\2\2\2\u0581\u0583\7\u00dc"+
+		"\2\2\u0582\u0581\3\2\2\2\u0582\u0583\3\2\2\2\u0583\u0584\3\2\2\2\u0584"+
+		"\u0585\7\u00d9\2\2\u0585\u0587\3\2\2\2\u0586\u0559\3\2\2\2\u0586\u0574"+
+		"\3\2\2\2\u0587\u00ad\3\2\2\2\u0588\u058a\7\u00c8\2\2\u0589\u0588\3\2\2"+
+		"\2\u0589\u058a\3\2\2\2\u058a\u058b\3\2\2\2\u058b\u058c\5\u00eex\2\u058c"+
+		"\u00af\3\2\2\2\u058d\u058e\5\u00a6T\2\u058e\u058f\7\u00a6\2\2\u058f\u0591"+
+		"\3\2\2\2\u0590\u058d\3\2\2\2\u0590\u0591\3\2\2\2\u0591\u0593\3\2\2\2\u0592"+
+		"\u0594\7\u00c8\2\2\u0593\u0592\3\2\2\2\u0593\u0594\3\2\2\2\u0594\u0595"+
+		"\3\2\2\2\u0595\u0596\5\u00eex\2\u0596\u00b1\3\2\2\2\u0597\u0599\7x\2\2"+
+		"\u0598\u0597\3\2\2\2\u0598\u0599\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059c"+
+		"\7T\2\2\u059b\u059d\7\u00c8\2\2\u059c\u059b\3\2\2\2\u059c\u059d\3\2\2"+
+		"\2\u059d\u059e\3\2\2\2\u059e\u059f\7\u00d6\2\2\u059f\u05a0\5t;\2\u05a0"+
+		"\u05a2\7\u00d7\2\2\u05a1\u05a3\5\u00c2b\2\u05a2\u05a1\3\2\2\2\u05a2\u05a3"+
+		"\3\2\2\2\u05a3\u05a6\3\2\2\2\u05a4\u05a5\7\u00dd\2\2\u05a5\u05a7\5x=\2"+
+		"\u05a6\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7\u05a8\3\2\2\2\u05a8\u05a9"+
+		"\5<\37\2\u05a9\u05b2\3\2\2\2\u05aa\u05ab\7\u0087\2\2\u05ab\u05ac\7\u00d6"+
+		"\2\2\u05ac\u05ad\5t;\2\u05ad\u05ae\7\u00d7\2\2\u05ae\u05af\7\u00a6\2\2"+
+		"\u05af\u05b0\5\u00a6T\2\u05b0\u05b2\3\2\2\2\u05b1\u0598\3\2\2\2\u05b1"+
+		"\u05aa\3\2\2\2\u05b2\u00b3\3\2\2\2\u05b3\u05b4\7h\2\2\u05b4\u05b5\7\u00d6"+
+		"\2\2\u05b5\u05b6\5\u00a6T\2\u05b6\u05b7\7\u00d7\2\2\u05b7\u05b8\7\u00da"+
+		"\2\2\u05b8\u05bd\5\u00b6\\\2\u05b9\u05ba\7\u00dc\2\2\u05ba\u05bc\5\u00b6"+
+		"\\\2\u05bb\u05b9\3\2\2\2\u05bc\u05bf\3\2\2\2\u05bd\u05bb\3\2\2\2\u05bd"+
+		"\u05be\3\2\2\2\u05be\u05c1\3\2\2\2\u05bf\u05bd\3\2\2\2\u05c0\u05c2\7\u00dc"+
+		"\2\2\u05c1\u05c0\3\2\2\2\u05c1\u05c2\3\2\2\2\u05c2\u05c3\3\2\2\2\u05c3"+
+		"\u05c4\7\u00db\2\2\u05c4\u00b5\3\2\2\2\u05c5\u05ca\5\u00a6T\2\u05c6\u05c7"+
+		"\7\u00dc\2\2\u05c7\u05c9\5\u00a6T\2\u05c8\u05c6\3\2\2\2\u05c9\u05cc\3"+
+		"\2\2\2\u05ca\u05c8\3\2\2\2\u05ca\u05cb\3\2\2\2\u05cb\u05cd\3\2\2\2\u05cc"+
+		"\u05ca\3\2\2\2\u05cd\u05ce\7\u00a6\2\2\u05ce\u05cf\5\u00a6T\2\u05cf\u00b7"+
+		"\3\2\2\2\u05d0\u05d1\7j\2\2\u05d1\u05d3\5\u00c8e\2\u05d2\u05d4\5\u00d6"+
+		"l\2\u05d3\u05d2\3\2\2\2\u05d3\u05d4\3\2\2\2\u05d4\u00b9\3\2\2\2\u05d5"+
+		"\u05d6\t\20\2\2\u05d6\u00bb\3\2\2\2\u05d7\u05df\7\u0085\2\2\u05d8\u05db"+
+		"\5\u00a6T\2\u05d9\u05da\7\u00a6\2\2\u05da\u05dc\5\u00a6T\2\u05db\u05d9"+
+		"\3\2\2\2\u05db\u05dc\3\2\2\2\u05dc\u05e0\3\2\2\2\u05dd\u05de\7\u0086\2"+
+		"\2\u05de\u05e0\5\u00a6T\2\u05df\u05d8\3\2\2\2\u05df\u05dd\3\2\2\2\u05e0"+
+		"\u00bd\3\2\2\2\u05e1\u05e6\5\u00c0a\2\u05e2\u05e3\7\u00dc\2\2\u05e3\u05e5"+
+		"\5\u00c0a\2\u05e4\u05e2\3\2\2\2\u05e5\u05e8\3\2\2\2\u05e6\u05e4\3\2\2"+
+		"\2\u05e6\u05e7\3\2\2\2\u05e7\u05ea\3\2\2\2\u05e8\u05e6\3\2\2\2\u05e9\u05eb"+
+		"\7\u00dc\2\2\u05ea\u05e9\3\2\2\2\u05ea\u05eb\3\2\2\2\u05eb\u00bf\3\2\2"+
+		"\2\u05ec\u05ef\5\u00a6T\2\u05ed\u05ee\7\u00a6\2\2\u05ee\u05f0\5\u00a6"+
+		"T\2\u05ef\u05ed\3\2\2\2\u05ef\u05f0\3\2\2\2\u05f0\u05f9\3\2\2\2\u05f1"+
+		"\u05f2\5\u00a6T\2\u05f2\u05f3\7\u00a6\2\2\u05f3\u05f5\3\2\2\2\u05f4\u05f1"+
+		"\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5\u05f6\3\2\2\2\u05f6\u05f7\7\u00c8\2"+
+		"\2\u05f7\u05f9\5\u00eex\2\u05f8\u05ec\3\2\2\2\u05f8\u05f4\3\2\2\2\u05f9"+
+		"\u00c1\3\2\2\2\u05fa\u05fb\7\u0082\2\2\u05fb\u05fc\7\u00d6\2\2\u05fc\u0601"+
+		"\5\u00c4c\2\u05fd\u05fe\7\u00dc\2\2\u05fe\u0600\5\u00c4c\2\u05ff\u05fd"+
+		"\3\2\2\2\u0600\u0603\3\2\2\2\u0601\u05ff\3\2\2\2\u0601\u0602\3\2\2\2\u0602"+
+		"\u0604\3\2\2\2\u0603\u0601\3\2\2\2\u0604\u0605\7\u00d7\2\2\u0605\u00c3"+
+		"\3\2\2\2\u0606\u0608\7\u00c8\2\2\u0607\u0606\3\2\2\2\u0607\u0608\3\2\2"+
+		"\2\u0608\u0609\3\2\2\2\u0609\u060a\7\u00e2\2\2\u060a\u00c5\3\2\2\2\u060b"+
+		"\u060d\5\u00ceh\2\u060c\u060e\5,\27\2\u060d\u060c\3\2\2\2\u060d\u060e"+
+		"\3\2\2\2\u060e\u0611\3\2\2\2\u060f\u0611\7x\2\2\u0610\u060b\3\2\2\2\u0610"+
+		"\u060f\3\2\2\2\u0611\u00c7\3\2\2\2\u0612\u0615\5\u00ceh\2\u0613\u0615"+
+		"\5\u00ccg\2\u0614\u0612\3\2\2\2\u0614\u0613\3\2\2\2\u0615\u0617\3\2\2"+
+		"\2\u0616\u0618\5,\27\2\u0617\u0616\3\2\2\2\u0617\u0618\3\2\2\2\u0618\u061d"+
+		"\3\2\2\2\u0619\u061d\5\u0112\u008a\2\u061a\u061d\7x\2\2\u061b\u061d\5"+
+		"\u00caf\2\u061c\u0614\3\2\2\2\u061c\u0619\3\2\2\2\u061c\u061a\3\2\2\2"+
+		"\u061c\u061b\3\2\2\2\u061d\u00c9\3\2\2\2\u061e\u0620\5.\30\2\u061f\u061e"+
+		"\3\2\2\2\u061f\u0620\3\2\2\2\u0620\u0622\3\2\2\2\u0621\u0623\7p\2\2\u0622"+
+		"\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2\2\2\u0624\u0626\5\u0108"+
+		"\u0085\2\u0625\u0624\3\2\2\2\u0625\u0626\3\2\2\2\u0626\u0628\3\2\2\2\u0627"+
+		"\u0629\7n\2\2\u0628\u0627\3\2\2\2\u0628\u0629\3\2\2\2\u0629\u063f\3\2"+
+		"\2\2\u062a\u062c\5\36\20\2\u062b\u062d\5\"\22\2\u062c\u062b\3\2\2\2\u062c"+
+		"\u062d\3\2\2\2\u062d\u0630\3\2\2\2\u062e\u062f\7N\2\2\u062f\u0631\5\u00c6"+
+		"d\2\u0630\u062e\3\2\2\2\u0630\u0631\3\2\2\2\u0631\u0634\3\2\2\2\u0632"+
+		"\u0633\7X\2\2\u0633\u0635\5 \21\2\u0634\u0632\3\2\2\2\u0634\u0635\3\2"+
+		"\2\2\u0635\u0640\3\2\2\2\u0636\u0637\7b\2\2\u0637\u0639\5\u010a\u0086"+
+		"\2\u0638\u063a\5\"\22\2\u0639\u0638\3\2\2\2\u0639\u063a\3\2\2\2\u063a"+
+		"\u063d\3\2\2\2\u063b\u063c\7N\2\2\u063c\u063e\5 \21\2\u063d\u063b\3\2"+
+		"\2\2\u063d\u063e\3\2\2\2\u063e\u0640\3\2\2\2\u063f\u062a\3\2\2\2\u063f"+
+		"\u0636\3\2\2\2\u0640\u0641\3\2\2\2\u0641\u0645\7\u00da\2\2\u0642\u0644"+
+		"\5\u0082B\2\u0643\u0642\3\2\2\2\u0644\u0647\3\2\2\2\u0645\u0643\3\2\2"+
+		"\2\u0645\u0646\3\2\2\2\u0646\u0648\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649"+
+		"\7\u00db\2\2\u0649\u00cb\3\2\2\2\u064a\u064f\5\u00fa~\2\u064b\u064c\7"+
+		"\u00c3\2\2\u064c\u064e\5\u00fc\177\2\u064d\u064b\3\2\2\2\u064e\u0651\3"+
+		"\2\2\2\u064f\u064d\3\2\2\2\u064f\u0650\3\2\2\2\u0650\u00cd\3\2\2\2\u0651"+
+		"\u064f\3\2\2\2\u0652\u0654\7i\2\2\u0653\u0652\3\2\2\2\u0653\u0654\3\2"+
+		"\2\2\u0654\u0656\3\2\2\2\u0655\u0657\7\u00c4\2\2\u0656\u0655\3\2\2\2\u0656"+
+		"\u0657\3\2\2\2\u0657\u0658\3\2\2\2\u0658\u0659\5\u00d0i\2\u0659\u00cf"+
+		"\3\2\2\2\u065a\u0668\5\u010a\u0086\2\u065b\u0660\5\u010a\u0086\2\u065c"+
+		"\u065d\7\u00c4\2\2\u065d\u065f\5\u010a\u0086\2\u065e\u065c\3\2\2\2\u065f"+
+		"\u0662\3\2\2\2\u0660\u065e\3\2\2\2\u0660\u0661\3\2\2\2\u0661\u0665\3\2"+
+		"\2\2\u0662\u0660\3\2\2\2\u0663\u0664\7\u00c4\2\2\u0664\u0666\5\u00d2j"+
+		"\2\u0665\u0663\3\2\2\2\u0665\u0666\3\2\2\2\u0666\u0668\3\2\2\2\u0667\u065a"+
+		"\3\2\2\2\u0667\u065b\3\2\2\2\u0668\u00d1\3\2\2\2\u0669\u066c\5\u010a\u0086"+
+		"\2\u066a\u066b\7\60\2\2\u066b\u066d\5\u010a\u0086\2\u066c\u066a\3\2\2"+
+		"\2\u066c\u066d\3\2\2\2\u066d\u067d\3\2\2\2\u066e\u066f\7\u00da\2\2\u066f"+
+		"\u0674\5\u00d2j\2\u0670\u0671\7\u00dc\2\2\u0671\u0673\5\u00d2j\2\u0672"+
+		"\u0670\3\2\2\2\u0673\u0676\3\2\2\2\u0674\u0672\3\2\2\2\u0674\u0675\3\2"+
+		"\2\2\u0675\u0678\3\2\2\2\u0676\u0674\3\2\2\2\u0677\u0679\7\u00dc\2\2\u0678"+
+		"\u0677\3\2\2\2\u0678\u0679\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067b\7\u00db"+
+		"\2\2\u067b\u067d\3\2\2\2\u067c\u0669\3\2\2\2\u067c\u066e\3\2\2\2\u067d"+
+		"\u00d3\3\2\2\2\u067e\u0683\5\u00ceh\2\u067f\u0680\7\u00dc\2\2\u0680\u0682"+
+		"\5\u00ceh\2\u0681\u067f\3\2\2\2\u0682\u0685\3\2\2\2\u0683\u0681\3\2\2"+
+		"\2\u0683\u0684\3\2\2\2\u0684\u00d5\3\2\2\2\u0685\u0683\3\2\2\2\u0686\u0690"+
+		"\7\u00d6\2\2\u0687\u068c\5\u00d8m\2\u0688\u0689\7\u00dc\2\2\u0689\u068b"+
+		"\5\u00d8m\2\u068a\u0688\3\2\2\2\u068b\u068e\3\2\2\2\u068c\u068a\3\2\2"+
+		"\2\u068c\u068d\3\2\2\2\u068d\u0691\3\2\2\2\u068e\u068c\3\2\2\2\u068f\u0691"+
+		"\5\u00bc_\2\u0690\u0687\3\2\2\2\u0690\u068f\3\2\2\2\u0690\u0691\3\2\2"+
+		"\2\u0691\u0693\3\2\2\2\u0692\u0694\7\u00dc\2\2\u0693\u0692\3\2\2\2\u0693"+
+		"\u0694\3\2\2\2\u0694\u0695\3\2\2\2\u0695\u0696\7\u00d7\2\2\u0696\u00d7"+
+		"\3\2\2\2\u0697\u0699\5\u00dan\2\u0698\u0697\3\2\2\2\u0698\u0699\3\2\2"+
+		"\2\u0699\u069b\3\2\2\2\u069a\u069c\7\u00c5\2\2\u069b\u069a\3\2\2\2\u069b"+
+		"\u069c\3\2\2\2\u069c\u069d\3\2\2\2\u069d\u06a1\5\u00a6T\2\u069e\u069f"+
+		"\7\u00c8\2\2\u069f\u06a1\5\u00eex\2\u06a0\u0698\3\2\2\2\u06a0\u069e\3"+
+		"\2\2\2\u06a1\u00d9\3\2\2\2\u06a2\u06a3\5\u010a\u0086\2\u06a3\u06a4\7\u00dd"+
+		"\2\2\u06a4\u00db\3\2\2\2\u06a5\u06c9\5\u00dep\2\u06a6\u06c9\5\u00e8u\2"+
+		"\u06a7\u06a8\7/\2\2\u06a8\u06ad\7\u00d6\2\2\u06a9\u06ab\5\u00be`\2\u06aa"+
+		"\u06ac\7\u00dc\2\2\u06ab\u06aa\3\2\2\2\u06ab\u06ac\3\2\2\2\u06ac\u06ae"+
+		"\3\2\2\2\u06ad\u06a9\3\2\2\2\u06ad\u06ae\3\2\2\2\u06ae\u06af\3\2\2\2\u06af"+
+		"\u06c9\7\u00d7\2\2\u06b0\u06b5\7\u00d8\2\2\u06b1\u06b3\5\u00be`\2\u06b2"+
+		"\u06b4\7\u00dc\2\2\u06b3\u06b2\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4\u06b6"+
+		"\3\2\2\2\u06b5\u06b1\3\2\2\2\u06b5\u06b6\3\2\2\2\u06b6\u06b7\3\2\2\2\u06b7"+
+		"\u06c9\7\u00d9\2\2\u06b8\u06b9\t\21\2\2\u06b9\u06c9\5\u00dco\2\u06ba\u06bd"+
+		"\5\u00e8u\2\u06bb\u06bd\5\u00dep\2\u06bc\u06ba\3\2\2\2\u06bc\u06bb\3\2"+
+		"\2\2\u06bd\u06c5\3\2\2\2\u06be\u06c1\7\u00d4\2\2\u06bf\u06c2\5\u00e8u"+
+		"\2\u06c0\u06c2\5\u00dep\2\u06c1\u06bf\3\2\2\2\u06c1\u06c0\3\2\2\2\u06c2"+
+		"\u06c4\3\2\2\2\u06c3\u06be\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5\u06c3\3\2"+
+		"\2\2\u06c5\u06c6\3\2\2\2\u06c6\u06c9\3\2\2\2\u06c7\u06c5\3\2\2\2\u06c8"+
+		"\u06a5\3\2\2\2\u06c8\u06a6\3\2\2\2\u06c8\u06a7\3\2\2\2\u06c8\u06b0\3\2"+
+		"\2\2\u06c8\u06b8\3\2\2\2\u06c8\u06bc\3\2\2\2\u06c9\u00dd\3\2\2\2\u06ca"+
+		"\u06d0\7k\2\2\u06cb\u06d0\5\u00e0q\2\u06cc\u06d0\5\u010e\u0088\2\u06cd"+
+		"\u06d0\5\u00e4s\2\u06ce\u06d0\5\u00ceh\2\u06cf\u06ca\3\2\2\2\u06cf\u06cb"+
+		"\3\2\2\2\u06cf\u06cc\3\2\2\2\u06cf\u06cd\3\2\2\2\u06cf\u06ce\3\2\2\2\u06d0"+
+		"\u00df\3\2\2\2\u06d1\u06d6\7\u00e6\2\2\u06d2\u06d6\7\63\2\2\u06d3\u06d6"+
+		"\5\u00e2r\2\u06d4\u06d6\5\u00e6t\2\u06d5\u06d1\3\2\2\2\u06d5\u06d2\3\2"+
+		"\2\2\u06d5\u06d3\3\2\2\2\u06d5\u06d4\3\2\2\2\u06d6\u00e1\3\2\2\2\u06d7"+
+		"\u06d8\t\22\2\2\u06d8\u00e3\3\2\2\2\u06d9\u06da\t\23\2\2\u06da\u06df\7"+
+		"\u00c2\2\2\u06db\u06e0\5\u010a\u0086\2\u06dc\u06e0\7\u008f\2\2\u06dd\u06e0"+
+		"\7\u008b\2\2\u06de\u06e0\7\u008c\2\2\u06df\u06db\3\2\2\2\u06df\u06dc\3"+
+		"\2\2\2\u06df\u06dd\3\2\2\2\u06df\u06de\3\2\2\2\u06e0\u06ec\3\2\2\2\u06e1"+
+		"\u06e5\5\u00c6d\2\u06e2\u06e5\5\u0100\u0081\2\u06e3\u06e5\5\u00e8u\2\u06e4"+
+		"\u06e1\3\2\2\2\u06e4\u06e2\3\2\2\2\u06e4\u06e3\3\2\2\2\u06e5\u06e6\3\2"+
+		"\2\2\u06e6\u06e9\7\u00c2\2\2\u06e7\u06ea\5\u010a\u0086\2\u06e8\u06ea\5"+
+		"\u0100\u0081\2\u06e9\u06e7\3\2\2\2\u06e9\u06e8\3\2\2\2\u06ea\u06ec\3\2"+
+		"\2\2\u06eb\u06d9\3\2\2\2\u06eb\u06e4\3\2\2\2\u06ec\u00e5\3\2\2\2\u06ed"+
+		"\u06ee\7\u00e3\2\2\u06ee\u00e7\3\2\2\2\u06ef\u06f1\7\u00ed\2\2\u06f0\u06f2"+
+		"\7\u00f5\2\2\u06f1\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f1\3\2\2"+
+		"\2\u06f3\u06f4\3\2\2\2\u06f4\u0705\3\2\2\2\u06f5\u06f7\7\u00ec\2\2\u06f6"+
+		"\u06f8\7\u00f5\2\2\u06f7\u06f6\3\2\2\2\u06f8\u06f9\3\2\2\2\u06f9\u06f7"+
+		"\3\2\2\2\u06f9\u06fa\3\2\2\2\u06fa\u0705\3\2\2\2\u06fb\u0705\7\u00ea\2"+
+		"\2\u06fc\u0700\7\u00eb\2\2\u06fd\u06ff\5\u00eav\2\u06fe\u06fd\3\2\2\2"+
+		"\u06ff\u0702\3\2\2\2\u0700\u06fe\3\2\2\2\u0700\u0701\3\2\2\2\u0701\u0703"+
+		"\3\2\2\2\u0702\u0700\3\2\2\2\u0703\u0705\7\u00eb\2\2\u0704\u06ef\3\2\2"+
+		"\2\u0704\u06f5\3\2\2\2\u0704\u06fb\3\2\2\2\u0704\u06fc\3\2\2\2\u0705\u00e9"+
+		"\3\2\2\2\u0706\u070a\7\u00f1\2\2\u0707\u070a\7\u00f0\2\2\u0708\u070a\5"+
+		"\u00eex\2\u0709\u0706\3\2\2\2\u0709\u0707\3\2\2\2\u0709\u0708\3\2\2\2"+
+		"\u070a\u00eb\3\2\2\2\u070b\u0710\5\u00eex\2\u070c\u070d\7\u00dc\2\2\u070d"+
+		"\u070f\5\u00eex\2\u070e\u070c\3\2\2\2\u070f\u0712\3\2\2\2\u0710\u070e"+
+		"\3\2\2\2\u0710\u0711\3\2\2\2\u0711\u00ed\3\2\2\2\u0712\u0710\3\2\2\2\u0713"+
+		"\u0717\5\u00f0y\2\u0714\u0716\5\u00f2z\2\u0715\u0714\3\2\2\2\u0716\u0719"+
+		"\3\2\2\2\u0717\u0715\3\2\2\2\u0717\u0718\3\2\2\2\u0718\u00ef\3\2\2\2\u0719"+
+		"\u0717\3\2\2\2\u071a\u0721\5\u00fa~\2\u071b\u0721\5\u00f4{\2\u071c\u071d"+
+		"\7\u00d6\2\2\u071d\u071e\5\u00b8]\2\u071e\u071f\7\u00d7\2\2\u071f\u0721"+
+		"\3\2\2\2\u0720\u071a\3\2\2\2\u0720\u071b\3\2\2\2\u0720\u071c\3\2\2\2\u0721"+
+		"\u00f1\3\2\2\2\u0722\u0723\7\u00c3\2\2\u0723\u0725\5\u00fc\177\2\u0724"+
+		"\u0726\5\u00f8}\2\u0725\u0724\3\2\2\2\u0725\u0726\3\2\2\2\u0726\u00f3"+
+		"\3\2\2\2\u0727\u0728\5\u00f6|\2\u0728\u0729\5\u00f8}\2\u0729\u00f5\3\2"+
+		"\2\2\u072a\u072f\5\u00ceh\2\u072b\u072f\5\u00e4s\2\u072c\u072f\5\u00fa"+
+		"~\2\u072d\u072f\5\u00a4S\2\u072e\u072a\3\2\2\2\u072e\u072b\3\2\2\2\u072e"+
+		"\u072c\3\2\2\2\u072e\u072d\3\2\2\2\u072f\u00f7\3\2\2\2\u0730\u0732\5,"+
+		"\27\2\u0731\u0730\3\2\2\2\u0731\u0732\3\2\2\2\u0732\u0734\3\2\2\2\u0733"+
+		"\u0735\5\u00d6l\2\u0734\u0733\3\2\2\2\u0735\u0736\3\2\2\2\u0736\u0734"+
+		"\3\2\2\2\u0736\u0737\3\2\2\2\u0737\u073b\3\2\2\2\u0738\u073a\5\u0102\u0082"+
+		"\2\u0739\u0738\3\2\2\2\u073a\u073d\3\2\2\2\u073b\u0739\3\2\2\2\u073b\u073c"+
+		"\3\2\2\2\u073c\u00f9\3\2\2\2\u073d\u073b\3\2\2\2\u073e\u0741\5\u0100\u0081"+
+		"\2\u073f\u0740\7\u00c2\2\2\u0740\u0742\5\u0100\u0081\2\u0741\u073f\3\2"+
+		"\2\2\u0741\u0742\3\2\2\2\u0742\u0748\3\2\2\2\u0743\u0744\5\u00c6d\2\u0744"+
+		"\u0745\7\u00c2\2\2\u0745\u0746\5\u0100\u0081\2\u0746\u0748\3\2\2\2\u0747"+
+		"\u073e\3\2\2\2\u0747\u0743\3\2\2\2\u0748\u00fb\3\2\2\2\u0749\u074c\5\u00fe"+
+		"\u0080\2\u074a\u074c\5\u0100\u0081\2\u074b\u0749\3\2\2\2\u074b\u074a\3"+
+		"\2\2\2\u074c\u00fd\3\2\2\2\u074d\u0753\5\u010a\u0086\2\u074e\u074f\7\u00da"+
+		"\2\2\u074f\u0750\5\u00a6T\2\u0750\u0751\7\u00db\2\2\u0751\u0753\3\2\2"+
+		"\2\u0752\u074d\3\2\2\2\u0752\u074e\3\2\2\2\u0753\u0757\3\2\2\2\u0754\u0756"+
+		"\5\u0102\u0082\2\u0755\u0754\3\2\2\2\u0756\u0759\3\2\2\2\u0757\u0755\3"+
+		"\2\2\2\u0757\u0758\3\2\2\2\u0758\u00ff\3\2\2\2\u0759\u0757\3\2\2\2\u075a"+
+		"\u075c\7\u00d3\2\2\u075b\u075a\3\2\2\2\u075c\u075f\3\2\2\2\u075d\u075b"+
+		"\3\2\2\2\u075d\u075e\3\2\2\2\u075e\u0766\3\2\2\2\u075f\u075d\3\2\2\2\u0760"+
+		"\u0767\7\u00e2\2\2\u0761\u0762\7\u00d3\2\2\u0762\u0763\7\u00da\2\2\u0763"+
+		"\u0764\5\u00a6T\2\u0764\u0765\7\u00db\2\2\u0765\u0767\3\2\2\2\u0766\u0760"+
+		"\3\2\2\2\u0766\u0761\3\2\2\2\u0767\u076b\3\2\2\2\u0768\u076a\5\u0102\u0082"+
+		"\2\u0769\u0768\3\2\2\2\u076a\u076d\3\2\2\2\u076b\u0769\3\2\2\2\u076b\u076c"+
+		"\3\2\2\2\u076c\u0101\3\2\2\2\u076d\u076b\3\2\2\2\u076e\u0770\7\u00d8\2"+
+		"\2\u076f\u0771\5\u00a6T\2\u0770\u076f\3\2\2\2\u0770\u0771\3\2\2\2\u0771"+
+		"\u0772\3\2\2\2\u0772\u0778\7\u00d9\2\2\u0773\u0774\7\u00da\2\2\u0774\u0775"+
+		"\5\u00a6T\2\u0775\u0776\7\u00db\2\2\u0776\u0778\3\2\2\2\u0777\u076e\3"+
+		"\2\2\2\u0777\u0773\3\2\2\2\u0778\u0103\3\2\2\2\u0779\u077b\5\u0106\u0084"+
+		"\2\u077a\u0779\3\2\2\2\u077a\u077b\3\2\2\2\u077b\u0782\3\2\2\2\u077c\u077e"+
+		"\7\u00dc\2\2\u077d\u077f\5\u0106\u0084\2\u077e\u077d\3\2\2\2\u077e\u077f"+
+		"\3\2\2\2\u077f\u0781\3\2\2\2\u0780\u077c\3\2\2\2\u0781\u0784\3\2\2\2\u0782"+
+		"\u0780\3\2\2\2\u0782\u0783\3\2\2\2\u0783\u0105\3\2\2\2\u0784\u0782\3\2"+
+		"\2\2\u0785\u078d\5\u00eex\2\u0786\u0787\7d\2\2\u0787\u0788\7\u00d6\2\2"+
+		"\u0788\u0789\5\u0104\u0083\2\u0789\u078a\7\u00d7\2\2\u078a\u078d\3\2\2"+
+		"\2\u078b\u078d\5\u00c0a\2\u078c\u0785\3\2\2\2\u078c\u0786\3\2\2\2\u078c"+
+		"\u078b\3\2\2\2\u078d\u0107\3\2\2\2\u078e\u078f\t\24\2\2\u078f\u0109\3"+
+		"\2\2\2\u0790\u0791\t\25\2\2\u0791\u010b\3\2\2\2\u0792\u0793\t\26\2\2\u0793"+
+		"\u010d\3\2\2\2\u0794\u0795\t\27\2\2\u0795\u010f\3\2\2\2\u0796\u0797\t"+
+		"\30\2\2\u0797\u0111\3\2\2\2\u0798\u0799\t\31\2\2\u0799\u0113\3\2\2\2\u079a"+
+		"\u079b\t\32\2\2\u079b\u0115\3\2\2\2\u00fe\u0117\u011b\u011d\u0125\u0128"+
+		"\u0142\u0146\u014b\u0150\u0156\u0164\u0168\u016e\u0173\u0178\u017f\u0185"+
+		"\u018c\u0193\u0196\u019a\u019e\u01a5\u01a8\u01ad\u01b0\u01b3\u01b6\u01bb"+
+		"\u01bf\u01c3\u01c8\u01cc\u01ce\u01d4\u01e0\u01f1\u01f8\u0200\u0204\u0209"+
+		"\u020f\u0217\u021f\u0225\u022c\u0233\u0238\u023e\u025b\u0269\u026d\u0276"+
+		"\u027a\u027f\u0299\u02a4\u02a8\u02ac\u02b5\u02bf\u02c4\u02ca\u02cf\u02d4"+
+		"\u02d9\u02de\u02e4\u02ea\u02f0\u0308\u030d\u0310\u031a\u031d\u032a\u0332"+
+		"\u0339\u033c\u0341\u0345\u034e\u0352\u036c\u0371\u0378\u037f\u0387\u038a"+
+		"\u0390\u0394\u0397\u039c\u03a0\u03a3\u03a6\u03a9\u03b1\u03b8\u03c1\u03ce"+
+		"\u03da\u03e0\u03e4\u03eb\u03f1\u03f5\u03fc\u0403\u0407\u040e\u0412\u0414"+
+		"\u041a\u0421\u0425\u0429\u0436\u0439\u0440\u0447\u044b\u0451\u0455\u045a"+
+		"\u045f\u0466\u046e\u0477\u047b\u0481\u048a\u048f\u0496\u049d\u04a3\u04c9"+
+		"\u04f3\u04fa\u04ff\u0501\u0527\u053d\u053f\u0544\u0549\u054e\u0551\u0557"+
+		"\u055d\u0564\u0569\u056f\u0579\u057e\u0582\u0586\u0589\u0590\u0593\u0598"+
+		"\u059c\u05a2\u05a6\u05b1\u05bd\u05c1\u05ca\u05d3\u05db\u05df\u05e6\u05ea"+
+		"\u05ef\u05f4\u05f8\u0601\u0607\u060d\u0610\u0614\u0617\u061c\u061f\u0622"+
+		"\u0625\u0628\u062c\u0630\u0634\u0639\u063d\u063f\u0645\u064f\u0653\u0656"+
+		"\u0660\u0665\u0667\u066c\u0674\u0678\u067c\u0683\u068c\u0690\u0693\u0698"+
+		"\u069b\u06a0\u06ab\u06ad\u06b3\u06b5\u06bc\u06c1\u06c5\u06c8\u06cf\u06d5"+
+		"\u06df\u06e4\u06e9\u06eb\u06f3\u06f9\u0700\u0704\u0709\u0710\u0717\u0720"+
+		"\u0725\u072e\u0731\u0736\u073b\u0741\u0747\u074b\u0752\u0757\u075d\u0766"+
+		"\u076b\u0770\u0777\u077a\u077e\u0782\u078c";
+	public static final ATN _ATN =
+		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
+	static {
+		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
+		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
+			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
+		}
+	}
+}
\ No newline at end of file
diff --git a/app/src/main/java/antlr/PhpParser.tokens b/app/src/main/java/antlr/PhpParser.tokens
new file mode 100644
index 0000000000000000000000000000000000000000..67693cc29a5a6fd4e9d85800def2113c4253c5ab
--- /dev/null
+++ b/app/src/main/java/antlr/PhpParser.tokens
@@ -0,0 +1,416 @@
+SeaWhitespace=1
+HtmlText=2
+XmlStart=3
+PHPStart=4
+HtmlScriptOpen=5
+HtmlStyleOpen=6
+HtmlComment=7
+HtmlDtd=8
+HtmlOpen=9
+Shebang=10
+Error=11
+XmlText=12
+XmlClose=13
+PHPStartInside=14
+HtmlClose=15
+HtmlSlashClose=16
+HtmlSlash=17
+HtmlEquals=18
+HtmlStartQuoteString=19
+HtmlStartDoubleQuoteString=20
+HtmlHex=21
+HtmlDecimal=22
+HtmlSpace=23
+HtmlName=24
+ErrorInside=25
+PHPStartInsideQuoteString=26
+HtmlEndQuoteString=27
+HtmlQuoteString=28
+ErrorHtmlQuote=29
+PHPStartDoubleQuoteString=30
+HtmlEndDoubleQuoteString=31
+HtmlDoubleQuoteString=32
+ErrorHtmlDoubleQuote=33
+ScriptText=34
+HtmlScriptClose=35
+PHPStartInsideScript=36
+StyleBody=37
+PHPEnd=38
+Whitespace=39
+MultiLineComment=40
+SingleLineComment=41
+ShellStyleComment=42
+AttributeStart=43
+Abstract=44
+Array=45
+As=46
+BinaryCast=47
+BoolType=48
+BooleanConstant=49
+Break=50
+Callable=51
+Case=52
+Catch=53
+Class=54
+Clone=55
+Const=56
+Continue=57
+Declare=58
+Default=59
+Do=60
+DoubleCast=61
+DoubleType=62
+Echo=63
+Else=64
+ElseIf=65
+Empty=66
+Enum_=67
+EndDeclare=68
+EndFor=69
+EndForeach=70
+EndIf=71
+EndSwitch=72
+EndWhile=73
+Eval=74
+Exit=75
+Extends=76
+Final=77
+Finally=78
+FloatCast=79
+For=80
+Foreach=81
+Function_=82
+Global=83
+Goto=84
+If=85
+Implements=86
+Import=87
+Include=88
+IncludeOnce=89
+InstanceOf=90
+InsteadOf=91
+Int8Cast=92
+Int16Cast=93
+Int64Type=94
+IntType=95
+Interface=96
+IsSet=97
+List=98
+LogicalAnd=99
+LogicalOr=100
+LogicalXor=101
+Match_=102
+Namespace=103
+New=104
+Null=105
+ObjectType=106
+Parent_=107
+Partial=108
+Print=109
+Private=110
+Protected=111
+Public=112
+Readonly=113
+Require=114
+RequireOnce=115
+Resource=116
+Return=117
+Static=118
+StringType=119
+Switch=120
+Throw=121
+Trait=122
+Try=123
+Typeof=124
+UintCast=125
+UnicodeCast=126
+Unset=127
+Use=128
+Var=129
+While=130
+Yield=131
+From=132
+LambdaFn=133
+Ticks=134
+Encoding=135
+StrictTypes=136
+Get=137
+Set=138
+Call=139
+CallStatic=140
+Constructor=141
+Destruct=142
+Wakeup=143
+Sleep=144
+Autoload=145
+IsSet__=146
+Unset__=147
+ToString__=148
+Invoke=149
+SetState=150
+Clone__=151
+DebugInfo=152
+Namespace__=153
+Class__=154
+Traic__=155
+Function__=156
+Method__=157
+Line__=158
+File__=159
+Dir__=160
+Spaceship=161
+Lgeneric=162
+Rgeneric=163
+DoubleArrow=164
+Inc=165
+Dec=166
+IsIdentical=167
+IsNoidentical=168
+IsEqual=169
+IsNotEq=170
+IsSmallerOrEqual=171
+IsGreaterOrEqual=172
+PlusEqual=173
+MinusEqual=174
+MulEqual=175
+Pow=176
+PowEqual=177
+DivEqual=178
+Concaequal=179
+ModEqual=180
+ShiftLeftEqual=181
+ShiftRightEqual=182
+AndEqual=183
+OrEqual=184
+XorEqual=185
+BooleanOr=186
+BooleanAnd=187
+NullCoalescing=188
+NullCoalescingEqual=189
+ShiftLeft=190
+ShiftRight=191
+DoubleColon=192
+ObjectOperator=193
+NamespaceSeparator=194
+Ellipsis=195
+Less=196
+Greater=197
+Ampersand=198
+Pipe=199
+Bang=200
+Caret=201
+Plus=202
+Minus=203
+Asterisk=204
+Percent=205
+Divide=206
+Tilde=207
+SuppressWarnings=208
+Dollar=209
+Dot=210
+QuestionMark=211
+OpenRoundBracket=212
+CloseRoundBracket=213
+OpenSquareBracket=214
+CloseSquareBracket=215
+OpenCurlyBracket=216
+CloseCurlyBracket=217
+Comma=218
+Colon=219
+SemiColon=220
+Eq=221
+Quote=222
+BackQuote=223
+VarName=224
+Label=225
+Octal=226
+Decimal=227
+Real=228
+Hex=229
+Binary=230
+BackQuoteString=231
+SingleQuoteString=232
+DoubleQuote=233
+StartNowDoc=234
+StartHereDoc=235
+ErrorPhp=236
+CurlyDollar=237
+UnicodeEscape=238
+StringPart=239
+Comment=240
+PHPEndSingleLineComment=241
+CommentEnd=242
+HereDocText=243
+XmlText2=244
+'<?xml'=3
+'?>'=13
+'/>'=16
+'#['=43
+'abstract'=44
+'array'=45
+'as'=46
+'binary'=47
+'break'=50
+'callable'=51
+'case'=52
+'catch'=53
+'class'=54
+'clone'=55
+'const'=56
+'continue'=57
+'declare'=58
+'default'=59
+'do'=60
+'real'=61
+'double'=62
+'echo'=63
+'else'=64
+'elseif'=65
+'empty'=66
+'enum'=67
+'enddeclare'=68
+'endfor'=69
+'endforeach'=70
+'endif'=71
+'endswitch'=72
+'endwhile'=73
+'eval'=74
+'die'=75
+'extends'=76
+'final'=77
+'finally'=78
+'float'=79
+'for'=80
+'foreach'=81
+'function'=82
+'global'=83
+'goto'=84
+'if'=85
+'implements'=86
+'import'=87
+'include'=88
+'include_once'=89
+'instanceof'=90
+'insteadof'=91
+'int8'=92
+'int16'=93
+'int64'=94
+'interface'=96
+'isset'=97
+'list'=98
+'and'=99
+'or'=100
+'xor'=101
+'match'=102
+'namespace'=103
+'new'=104
+'null'=105
+'object'=106
+'parent'=107
+'partial'=108
+'print'=109
+'private'=110
+'protected'=111
+'public'=112
+'readonly'=113
+'require'=114
+'require_once'=115
+'resource'=116
+'return'=117
+'static'=118
+'string'=119
+'switch'=120
+'throw'=121
+'trait'=122
+'try'=123
+'clrtypeof'=124
+'unicode'=126
+'unset'=127
+'use'=128
+'var'=129
+'while'=130
+'yield'=131
+'from'=132
+'fn'=133
+'ticks'=134
+'encoding'=135
+'strict_types'=136
+'__get'=137
+'__set'=138
+'__call'=139
+'__callstatic'=140
+'__construct'=141
+'__destruct'=142
+'__wakeup'=143
+'__sleep'=144
+'__autoload'=145
+'__isset'=146
+'__unset'=147
+'__tostring'=148
+'__invoke'=149
+'__set_state'=150
+'__clone'=151
+'__debuginfo'=152
+'__namespace__'=153
+'__class__'=154
+'__trait__'=155
+'__function__'=156
+'__method__'=157
+'__line__'=158
+'__file__'=159
+'__dir__'=160
+'<=>'=161
+'<:'=162
+':>'=163
+'=>'=164
+'++'=165
+'--'=166
+'==='=167
+'!=='=168
+'=='=169
+'<='=171
+'>='=172
+'+='=173
+'-='=174
+'*='=175
+'**'=176
+'**='=177
+'/='=178
+'.='=179
+'%='=180
+'<<='=181
+'>>='=182
+'&='=183
+'|='=184
+'^='=185
+'||'=186
+'&&'=187
+'??'=188
+'??='=189
+'<<'=190
+'>>'=191
+'::'=192
+'->'=193
+'\\'=194
+'...'=195
+'&'=198
+'|'=199
+'!'=200
+'^'=201
+'+'=202
+'-'=203
+'*'=204
+'%'=205
+'~'=207
+'@'=208
+'.'=210
+'('=212
+')'=213
+'['=214
+']'=215
+'}'=217
+','=218
+':'=219
+';'=220
+'\''=222
+'`'=223
diff --git a/app/src/main/java/antlr/PhpParserBaseListener.java b/app/src/main/java/antlr/PhpParserBaseListener.java
new file mode 100644
index 0000000000000000000000000000000000000000..5df905600e7cc30817e70c996a20cec8aa187dca
--- /dev/null
+++ b/app/src/main/java/antlr/PhpParserBaseListener.java
@@ -0,0 +1,1997 @@
+package antlr;
+
+// Generated from PhpParser.g4 by ANTLR 4.5
+
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.misc.NotNull;
+import org.antlr.v4.runtime.tree.ErrorNode;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+/**
+ * This class provides an empty implementation of {@link PhpParserListener},
+ * which can be extended to create a listener which only needs to handle a subset
+ * of the available methods.
+ */
+public class PhpParserBaseListener implements PhpParserListener {
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterHtmlDocument(PhpParser.HtmlDocumentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitHtmlDocument(PhpParser.HtmlDocumentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInlineHtml(PhpParser.InlineHtmlContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInlineHtml(PhpParser.InlineHtmlContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterHtmlElement(PhpParser.HtmlElementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitHtmlElement(PhpParser.HtmlElementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterScriptText(PhpParser.ScriptTextContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitScriptText(PhpParser.ScriptTextContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterPhpBlock(PhpParser.PhpBlockContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitPhpBlock(PhpParser.PhpBlockContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterImportStatement(PhpParser.ImportStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitImportStatement(PhpParser.ImportStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTopStatement(PhpParser.TopStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTopStatement(PhpParser.TopStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterUseDeclaration(PhpParser.UseDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitUseDeclaration(PhpParser.UseDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterUseDeclarationContentList(PhpParser.UseDeclarationContentListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitUseDeclarationContentList(PhpParser.UseDeclarationContentListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterUseDeclarationContent(PhpParser.UseDeclarationContentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitUseDeclarationContent(PhpParser.UseDeclarationContentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterNamespaceDeclaration(PhpParser.NamespaceDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitNamespaceDeclaration(PhpParser.NamespaceDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterNamespaceStatement(PhpParser.NamespaceStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitNamespaceStatement(PhpParser.NamespaceStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterFunctionDeclaration(PhpParser.FunctionDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitFunctionDeclaration(PhpParser.FunctionDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterClassDeclaration(PhpParser.ClassDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitClassDeclaration(PhpParser.ClassDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterClassEntryType(PhpParser.ClassEntryTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitClassEntryType(PhpParser.ClassEntryTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInterfaceList(PhpParser.InterfaceListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInterfaceList(PhpParser.InterfaceListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeParameterListInBrackets(PhpParser.TypeParameterListInBracketsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeParameterListInBrackets(PhpParser.TypeParameterListInBracketsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeParameterList(PhpParser.TypeParameterListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeParameterList(PhpParser.TypeParameterListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeParameterWithDefaultsList(PhpParser.TypeParameterWithDefaultsListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeParameterWithDefaultsList(PhpParser.TypeParameterWithDefaultsListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeParameterDecl(PhpParser.TypeParameterDeclContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeParameterDecl(PhpParser.TypeParameterDeclContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeParameterWithDefaultDecl(PhpParser.TypeParameterWithDefaultDeclContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeParameterWithDefaultDecl(PhpParser.TypeParameterWithDefaultDeclContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterGenericDynamicArgs(PhpParser.GenericDynamicArgsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitGenericDynamicArgs(PhpParser.GenericDynamicArgsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAttributes(PhpParser.AttributesContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAttributes(PhpParser.AttributesContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAttributeGroup(PhpParser.AttributeGroupContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAttributeGroup(PhpParser.AttributeGroupContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAttribute(PhpParser.AttributeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAttribute(PhpParser.AttributeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInnerStatementList(PhpParser.InnerStatementListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInnerStatementList(PhpParser.InnerStatementListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInnerStatement(PhpParser.InnerStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInnerStatement(PhpParser.InnerStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterStatement(PhpParser.StatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitStatement(PhpParser.StatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterEmptyStatement_(PhpParser.EmptyStatement_Context ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitEmptyStatement_(PhpParser.EmptyStatement_Context ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterBlockStatement(PhpParser.BlockStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitBlockStatement(PhpParser.BlockStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterIfStatement(PhpParser.IfStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitIfStatement(PhpParser.IfStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterElseIfStatement(PhpParser.ElseIfStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitElseIfStatement(PhpParser.ElseIfStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterElseIfColonStatement(PhpParser.ElseIfColonStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitElseIfColonStatement(PhpParser.ElseIfColonStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterElseStatement(PhpParser.ElseStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitElseStatement(PhpParser.ElseStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterElseColonStatement(PhpParser.ElseColonStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitElseColonStatement(PhpParser.ElseColonStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterWhileStatement(PhpParser.WhileStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitWhileStatement(PhpParser.WhileStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterDoWhileStatement(PhpParser.DoWhileStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitDoWhileStatement(PhpParser.DoWhileStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterForStatement(PhpParser.ForStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitForStatement(PhpParser.ForStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterForInit(PhpParser.ForInitContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitForInit(PhpParser.ForInitContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterForUpdate(PhpParser.ForUpdateContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitForUpdate(PhpParser.ForUpdateContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterSwitchStatement(PhpParser.SwitchStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitSwitchStatement(PhpParser.SwitchStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterSwitchBlock(PhpParser.SwitchBlockContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitSwitchBlock(PhpParser.SwitchBlockContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterBreakStatement(PhpParser.BreakStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitBreakStatement(PhpParser.BreakStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterContinueStatement(PhpParser.ContinueStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitContinueStatement(PhpParser.ContinueStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterReturnStatement(PhpParser.ReturnStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitReturnStatement(PhpParser.ReturnStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterExpressionStatement(PhpParser.ExpressionStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitExpressionStatement(PhpParser.ExpressionStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterUnsetStatement(PhpParser.UnsetStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitUnsetStatement(PhpParser.UnsetStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterForeachStatement(PhpParser.ForeachStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitForeachStatement(PhpParser.ForeachStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTryCatchFinally(PhpParser.TryCatchFinallyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTryCatchFinally(PhpParser.TryCatchFinallyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterCatchClause(PhpParser.CatchClauseContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitCatchClause(PhpParser.CatchClauseContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterFinallyStatement(PhpParser.FinallyStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitFinallyStatement(PhpParser.FinallyStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterThrowStatement(PhpParser.ThrowStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitThrowStatement(PhpParser.ThrowStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterGotoStatement(PhpParser.GotoStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitGotoStatement(PhpParser.GotoStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterDeclareStatement(PhpParser.DeclareStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitDeclareStatement(PhpParser.DeclareStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInlineHtmlStatement(PhpParser.InlineHtmlStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInlineHtmlStatement(PhpParser.InlineHtmlStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterDeclareList(PhpParser.DeclareListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitDeclareList(PhpParser.DeclareListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterDirective(PhpParser.DirectiveContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitDirective(PhpParser.DirectiveContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterFormalParameterList(PhpParser.FormalParameterListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitFormalParameterList(PhpParser.FormalParameterListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterFormalParameter(PhpParser.FormalParameterContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitFormalParameter(PhpParser.FormalParameterContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeHint(PhpParser.TypeHintContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeHint(PhpParser.TypeHintContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterGlobalStatement(PhpParser.GlobalStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitGlobalStatement(PhpParser.GlobalStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterGlobalVar(PhpParser.GlobalVarContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitGlobalVar(PhpParser.GlobalVarContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterEchoStatement(PhpParser.EchoStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitEchoStatement(PhpParser.EchoStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterStaticVariableStatement(PhpParser.StaticVariableStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitStaticVariableStatement(PhpParser.StaticVariableStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterClassStatement(PhpParser.ClassStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitClassStatement(PhpParser.ClassStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTraitAdaptations(PhpParser.TraitAdaptationsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTraitAdaptations(PhpParser.TraitAdaptationsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTraitAdaptationStatement(PhpParser.TraitAdaptationStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTraitAdaptationStatement(PhpParser.TraitAdaptationStatementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTraitPrecedence(PhpParser.TraitPrecedenceContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTraitPrecedence(PhpParser.TraitPrecedenceContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTraitAlias(PhpParser.TraitAliasContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTraitAlias(PhpParser.TraitAliasContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTraitMethodReference(PhpParser.TraitMethodReferenceContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTraitMethodReference(PhpParser.TraitMethodReferenceContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterBaseCtorCall(PhpParser.BaseCtorCallContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitBaseCtorCall(PhpParser.BaseCtorCallContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterReturnTypeDecl(PhpParser.ReturnTypeDeclContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitReturnTypeDecl(PhpParser.ReturnTypeDeclContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMethodBody(PhpParser.MethodBodyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMethodBody(PhpParser.MethodBodyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterPropertyModifiers(PhpParser.PropertyModifiersContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitPropertyModifiers(PhpParser.PropertyModifiersContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMemberModifiers(PhpParser.MemberModifiersContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMemberModifiers(PhpParser.MemberModifiersContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterVariableInitializer(PhpParser.VariableInitializerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitVariableInitializer(PhpParser.VariableInitializerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterIdentifierInitializer(PhpParser.IdentifierInitializerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitIdentifierInitializer(PhpParser.IdentifierInitializerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterGlobalConstantDeclaration(PhpParser.GlobalConstantDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitGlobalConstantDeclaration(PhpParser.GlobalConstantDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterEnumDeclaration(PhpParser.EnumDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitEnumDeclaration(PhpParser.EnumDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterEnumItem(PhpParser.EnumItemContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitEnumItem(PhpParser.EnumItemContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterExpressionList(PhpParser.ExpressionListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitExpressionList(PhpParser.ExpressionListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterParentheses(PhpParser.ParenthesesContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitParentheses(PhpParser.ParenthesesContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterChainExpression(PhpParser.ChainExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitChainExpression(PhpParser.ChainExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterSpecialWordExpression(PhpParser.SpecialWordExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitSpecialWordExpression(PhpParser.SpecialWordExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterArrayCreationExpression(PhpParser.ArrayCreationExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitArrayCreationExpression(PhpParser.ArrayCreationExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterBackQuoteStringExpression(PhpParser.BackQuoteStringExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitBackQuoteStringExpression(PhpParser.BackQuoteStringExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMatchExpression(PhpParser.MatchExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMatchExpression(PhpParser.MatchExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterLogicalExpression(PhpParser.LogicalExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitLogicalExpression(PhpParser.LogicalExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterPrintExpression(PhpParser.PrintExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitPrintExpression(PhpParser.PrintExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAssignmentExpression(PhpParser.AssignmentExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAssignmentExpression(PhpParser.AssignmentExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterPostfixIncDecExpression(PhpParser.PostfixIncDecExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitPostfixIncDecExpression(PhpParser.PostfixIncDecExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterCloneExpression(PhpParser.CloneExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitCloneExpression(PhpParser.CloneExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterUnaryOperatorExpression(PhpParser.UnaryOperatorExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitUnaryOperatorExpression(PhpParser.UnaryOperatorExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterNewExpression(PhpParser.NewExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitNewExpression(PhpParser.NewExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterParenthesisExpression(PhpParser.ParenthesisExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitParenthesisExpression(PhpParser.ParenthesisExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterSpaceshipExpression(PhpParser.SpaceshipExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitSpaceshipExpression(PhpParser.SpaceshipExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterConditionalExpression(PhpParser.ConditionalExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitConditionalExpression(PhpParser.ConditionalExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterNullCoalescingExpression(PhpParser.NullCoalescingExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitNullCoalescingExpression(PhpParser.NullCoalescingExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterArithmeticExpression(PhpParser.ArithmeticExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitArithmeticExpression(PhpParser.ArithmeticExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterIndexerExpression(PhpParser.IndexerExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitIndexerExpression(PhpParser.IndexerExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterScalarExpression(PhpParser.ScalarExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitScalarExpression(PhpParser.ScalarExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterPrefixIncDecExpression(PhpParser.PrefixIncDecExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitPrefixIncDecExpression(PhpParser.PrefixIncDecExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterComparisonExpression(PhpParser.ComparisonExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitComparisonExpression(PhpParser.ComparisonExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterCastExpression(PhpParser.CastExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitCastExpression(PhpParser.CastExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInstanceOfExpression(PhpParser.InstanceOfExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInstanceOfExpression(PhpParser.InstanceOfExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterArrayDestructExpression(PhpParser.ArrayDestructExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitArrayDestructExpression(PhpParser.ArrayDestructExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterLambdaFunctionExpression(PhpParser.LambdaFunctionExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitLambdaFunctionExpression(PhpParser.LambdaFunctionExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterBitwiseExpression(PhpParser.BitwiseExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitBitwiseExpression(PhpParser.BitwiseExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAssignable(PhpParser.AssignableContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAssignable(PhpParser.AssignableContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterArrayCreation(PhpParser.ArrayCreationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitArrayCreation(PhpParser.ArrayCreationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterArrayDestructuring(PhpParser.ArrayDestructuringContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitArrayDestructuring(PhpParser.ArrayDestructuringContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterIndexedDestructItem(PhpParser.IndexedDestructItemContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitIndexedDestructItem(PhpParser.IndexedDestructItemContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterKeyedDestructItem(PhpParser.KeyedDestructItemContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitKeyedDestructItem(PhpParser.KeyedDestructItemContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterLambdaFunctionExpr(PhpParser.LambdaFunctionExprContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitLambdaFunctionExpr(PhpParser.LambdaFunctionExprContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMatchExpr(PhpParser.MatchExprContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMatchExpr(PhpParser.MatchExprContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMatchItem(PhpParser.MatchItemContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMatchItem(PhpParser.MatchItemContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterNewExpr(PhpParser.NewExprContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitNewExpr(PhpParser.NewExprContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAssignmentOperator(PhpParser.AssignmentOperatorContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAssignmentOperator(PhpParser.AssignmentOperatorContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterYieldExpression(PhpParser.YieldExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitYieldExpression(PhpParser.YieldExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterArrayItemList(PhpParser.ArrayItemListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitArrayItemList(PhpParser.ArrayItemListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterArrayItem(PhpParser.ArrayItemContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitArrayItem(PhpParser.ArrayItemContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterLambdaFunctionUseVars(PhpParser.LambdaFunctionUseVarsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitLambdaFunctionUseVars(PhpParser.LambdaFunctionUseVarsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterLambdaFunctionUseVar(PhpParser.LambdaFunctionUseVarContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitLambdaFunctionUseVar(PhpParser.LambdaFunctionUseVarContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterQualifiedStaticTypeRef(PhpParser.QualifiedStaticTypeRefContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitQualifiedStaticTypeRef(PhpParser.QualifiedStaticTypeRefContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeRef(PhpParser.TypeRefContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeRef(PhpParser.TypeRefContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAnonymousClass(PhpParser.AnonymousClassContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAnonymousClass(PhpParser.AnonymousClassContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterIndirectTypeRef(PhpParser.IndirectTypeRefContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitIndirectTypeRef(PhpParser.IndirectTypeRefContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterQualifiedNamespaceName(PhpParser.QualifiedNamespaceNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitQualifiedNamespaceName(PhpParser.QualifiedNamespaceNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterNamespaceNameList(PhpParser.NamespaceNameListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitNamespaceNameList(PhpParser.NamespaceNameListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterNamespaceNameTail(PhpParser.NamespaceNameTailContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitNamespaceNameTail(PhpParser.NamespaceNameTailContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterQualifiedNamespaceNameList(PhpParser.QualifiedNamespaceNameListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitQualifiedNamespaceNameList(PhpParser.QualifiedNamespaceNameListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterArguments(PhpParser.ArgumentsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitArguments(PhpParser.ArgumentsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterActualArgument(PhpParser.ActualArgumentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitActualArgument(PhpParser.ActualArgumentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterArgumentName(PhpParser.ArgumentNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitArgumentName(PhpParser.ArgumentNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterConstantInitializer(PhpParser.ConstantInitializerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitConstantInitializer(PhpParser.ConstantInitializerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterConstant(PhpParser.ConstantContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitConstant(PhpParser.ConstantContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterLiteralConstant(PhpParser.LiteralConstantContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitLiteralConstant(PhpParser.LiteralConstantContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterNumericConstant(PhpParser.NumericConstantContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitNumericConstant(PhpParser.NumericConstantContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterClassConstant(PhpParser.ClassConstantContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitClassConstant(PhpParser.ClassConstantContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterStringConstant(PhpParser.StringConstantContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitStringConstant(PhpParser.StringConstantContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterString(PhpParser.StringContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitString(PhpParser.StringContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInterpolatedStringPart(PhpParser.InterpolatedStringPartContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInterpolatedStringPart(PhpParser.InterpolatedStringPartContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterChainList(PhpParser.ChainListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitChainList(PhpParser.ChainListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterChain(PhpParser.ChainContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitChain(PhpParser.ChainContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterChainOrigin(PhpParser.ChainOriginContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitChainOrigin(PhpParser.ChainOriginContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMemberAccess(PhpParser.MemberAccessContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMemberAccess(PhpParser.MemberAccessContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterFunctionCall(PhpParser.FunctionCallContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitFunctionCall(PhpParser.FunctionCallContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterFunctionCallName(PhpParser.FunctionCallNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitFunctionCallName(PhpParser.FunctionCallNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterActualArguments(PhpParser.ActualArgumentsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitActualArguments(PhpParser.ActualArgumentsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterChainBase(PhpParser.ChainBaseContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitChainBase(PhpParser.ChainBaseContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterKeyedFieldName(PhpParser.KeyedFieldNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitKeyedFieldName(PhpParser.KeyedFieldNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterKeyedSimpleFieldName(PhpParser.KeyedSimpleFieldNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitKeyedSimpleFieldName(PhpParser.KeyedSimpleFieldNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterKeyedVariable(PhpParser.KeyedVariableContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitKeyedVariable(PhpParser.KeyedVariableContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterSquareCurlyExpression(PhpParser.SquareCurlyExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitSquareCurlyExpression(PhpParser.SquareCurlyExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAssignmentList(PhpParser.AssignmentListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAssignmentList(PhpParser.AssignmentListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAssignmentListElement(PhpParser.AssignmentListElementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAssignmentListElement(PhpParser.AssignmentListElementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterModifier(PhpParser.ModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitModifier(PhpParser.ModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterIdentifier(PhpParser.IdentifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitIdentifier(PhpParser.IdentifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMemberModifier(PhpParser.MemberModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMemberModifier(PhpParser.MemberModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMagicConstant(PhpParser.MagicConstantContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMagicConstant(PhpParser.MagicConstantContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMagicMethod(PhpParser.MagicMethodContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMagicMethod(PhpParser.MagicMethodContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterPrimitiveType(PhpParser.PrimitiveTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitPrimitiveType(PhpParser.PrimitiveTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterCastOperation(PhpParser.CastOperationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitCastOperation(PhpParser.CastOperationContext ctx) { }
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterEveryRule(ParserRuleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitEveryRule(ParserRuleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void visitTerminal(TerminalNode node) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void visitErrorNode(ErrorNode node) { }
+}
\ No newline at end of file
diff --git a/app/src/main/java/antlr/PhpParserListener.java b/app/src/main/java/antlr/PhpParserListener.java
new file mode 100644
index 0000000000000000000000000000000000000000..98ba3a0bbbf46cdaccc6d72cbb58bca4650c70fa
--- /dev/null
+++ b/app/src/main/java/antlr/PhpParserListener.java
@@ -0,0 +1,1694 @@
+package antlr;
+
+// Generated from PhpParser.g4 by ANTLR 4.5
+import org.antlr.v4.runtime.misc.NotNull;
+import org.antlr.v4.runtime.tree.ParseTreeListener;
+
+/**
+ * This interface defines a complete listener for a parse tree produced by
+ * {@link PhpParser}.
+ */
+public interface PhpParserListener extends ParseTreeListener {
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#htmlDocument}.
+	 * @param ctx the parse tree
+	 */
+	void enterHtmlDocument(PhpParser.HtmlDocumentContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#htmlDocument}.
+	 * @param ctx the parse tree
+	 */
+	void exitHtmlDocument(PhpParser.HtmlDocumentContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#inlineHtml}.
+	 * @param ctx the parse tree
+	 */
+	void enterInlineHtml(PhpParser.InlineHtmlContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#inlineHtml}.
+	 * @param ctx the parse tree
+	 */
+	void exitInlineHtml(PhpParser.InlineHtmlContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#htmlElement}.
+	 * @param ctx the parse tree
+	 */
+	void enterHtmlElement(PhpParser.HtmlElementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#htmlElement}.
+	 * @param ctx the parse tree
+	 */
+	void exitHtmlElement(PhpParser.HtmlElementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#scriptText}.
+	 * @param ctx the parse tree
+	 */
+	void enterScriptText(PhpParser.ScriptTextContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#scriptText}.
+	 * @param ctx the parse tree
+	 */
+	void exitScriptText(PhpParser.ScriptTextContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#phpBlock}.
+	 * @param ctx the parse tree
+	 */
+	void enterPhpBlock(PhpParser.PhpBlockContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#phpBlock}.
+	 * @param ctx the parse tree
+	 */
+	void exitPhpBlock(PhpParser.PhpBlockContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#importStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterImportStatement(PhpParser.ImportStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#importStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitImportStatement(PhpParser.ImportStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#topStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterTopStatement(PhpParser.TopStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#topStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitTopStatement(PhpParser.TopStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#useDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterUseDeclaration(PhpParser.UseDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#useDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitUseDeclaration(PhpParser.UseDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#useDeclarationContentList}.
+	 * @param ctx the parse tree
+	 */
+	void enterUseDeclarationContentList(PhpParser.UseDeclarationContentListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#useDeclarationContentList}.
+	 * @param ctx the parse tree
+	 */
+	void exitUseDeclarationContentList(PhpParser.UseDeclarationContentListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#useDeclarationContent}.
+	 * @param ctx the parse tree
+	 */
+	void enterUseDeclarationContent(PhpParser.UseDeclarationContentContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#useDeclarationContent}.
+	 * @param ctx the parse tree
+	 */
+	void exitUseDeclarationContent(PhpParser.UseDeclarationContentContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#namespaceDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterNamespaceDeclaration(PhpParser.NamespaceDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#namespaceDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitNamespaceDeclaration(PhpParser.NamespaceDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#namespaceStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterNamespaceStatement(PhpParser.NamespaceStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#namespaceStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitNamespaceStatement(PhpParser.NamespaceStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#functionDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterFunctionDeclaration(PhpParser.FunctionDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#functionDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitFunctionDeclaration(PhpParser.FunctionDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#classDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterClassDeclaration(PhpParser.ClassDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#classDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitClassDeclaration(PhpParser.ClassDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#classEntryType}.
+	 * @param ctx the parse tree
+	 */
+	void enterClassEntryType(PhpParser.ClassEntryTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#classEntryType}.
+	 * @param ctx the parse tree
+	 */
+	void exitClassEntryType(PhpParser.ClassEntryTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#interfaceList}.
+	 * @param ctx the parse tree
+	 */
+	void enterInterfaceList(PhpParser.InterfaceListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#interfaceList}.
+	 * @param ctx the parse tree
+	 */
+	void exitInterfaceList(PhpParser.InterfaceListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#typeParameterListInBrackets}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeParameterListInBrackets(PhpParser.TypeParameterListInBracketsContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#typeParameterListInBrackets}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeParameterListInBrackets(PhpParser.TypeParameterListInBracketsContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#typeParameterList}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeParameterList(PhpParser.TypeParameterListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#typeParameterList}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeParameterList(PhpParser.TypeParameterListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#typeParameterWithDefaultsList}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeParameterWithDefaultsList(PhpParser.TypeParameterWithDefaultsListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#typeParameterWithDefaultsList}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeParameterWithDefaultsList(PhpParser.TypeParameterWithDefaultsListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#typeParameterDecl}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeParameterDecl(PhpParser.TypeParameterDeclContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#typeParameterDecl}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeParameterDecl(PhpParser.TypeParameterDeclContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#typeParameterWithDefaultDecl}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeParameterWithDefaultDecl(PhpParser.TypeParameterWithDefaultDeclContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#typeParameterWithDefaultDecl}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeParameterWithDefaultDecl(PhpParser.TypeParameterWithDefaultDeclContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#genericDynamicArgs}.
+	 * @param ctx the parse tree
+	 */
+	void enterGenericDynamicArgs(PhpParser.GenericDynamicArgsContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#genericDynamicArgs}.
+	 * @param ctx the parse tree
+	 */
+	void exitGenericDynamicArgs(PhpParser.GenericDynamicArgsContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#attributes}.
+	 * @param ctx the parse tree
+	 */
+	void enterAttributes(PhpParser.AttributesContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#attributes}.
+	 * @param ctx the parse tree
+	 */
+	void exitAttributes(PhpParser.AttributesContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#attributeGroup}.
+	 * @param ctx the parse tree
+	 */
+	void enterAttributeGroup(PhpParser.AttributeGroupContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#attributeGroup}.
+	 * @param ctx the parse tree
+	 */
+	void exitAttributeGroup(PhpParser.AttributeGroupContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#attribute}.
+	 * @param ctx the parse tree
+	 */
+	void enterAttribute(PhpParser.AttributeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#attribute}.
+	 * @param ctx the parse tree
+	 */
+	void exitAttribute(PhpParser.AttributeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#innerStatementList}.
+	 * @param ctx the parse tree
+	 */
+	void enterInnerStatementList(PhpParser.InnerStatementListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#innerStatementList}.
+	 * @param ctx the parse tree
+	 */
+	void exitInnerStatementList(PhpParser.InnerStatementListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#innerStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterInnerStatement(PhpParser.InnerStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#innerStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitInnerStatement(PhpParser.InnerStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#statement}.
+	 * @param ctx the parse tree
+	 */
+	void enterStatement(PhpParser.StatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#statement}.
+	 * @param ctx the parse tree
+	 */
+	void exitStatement(PhpParser.StatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#emptyStatement_}.
+	 * @param ctx the parse tree
+	 */
+	void enterEmptyStatement_(PhpParser.EmptyStatement_Context ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#emptyStatement_}.
+	 * @param ctx the parse tree
+	 */
+	void exitEmptyStatement_(PhpParser.EmptyStatement_Context ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#blockStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterBlockStatement(PhpParser.BlockStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#blockStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitBlockStatement(PhpParser.BlockStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#ifStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterIfStatement(PhpParser.IfStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#ifStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitIfStatement(PhpParser.IfStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#elseIfStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterElseIfStatement(PhpParser.ElseIfStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#elseIfStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitElseIfStatement(PhpParser.ElseIfStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#elseIfColonStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterElseIfColonStatement(PhpParser.ElseIfColonStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#elseIfColonStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitElseIfColonStatement(PhpParser.ElseIfColonStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#elseStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterElseStatement(PhpParser.ElseStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#elseStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitElseStatement(PhpParser.ElseStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#elseColonStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterElseColonStatement(PhpParser.ElseColonStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#elseColonStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitElseColonStatement(PhpParser.ElseColonStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#whileStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterWhileStatement(PhpParser.WhileStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#whileStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitWhileStatement(PhpParser.WhileStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#doWhileStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterDoWhileStatement(PhpParser.DoWhileStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#doWhileStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitDoWhileStatement(PhpParser.DoWhileStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#forStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterForStatement(PhpParser.ForStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#forStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitForStatement(PhpParser.ForStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#forInit}.
+	 * @param ctx the parse tree
+	 */
+	void enterForInit(PhpParser.ForInitContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#forInit}.
+	 * @param ctx the parse tree
+	 */
+	void exitForInit(PhpParser.ForInitContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#forUpdate}.
+	 * @param ctx the parse tree
+	 */
+	void enterForUpdate(PhpParser.ForUpdateContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#forUpdate}.
+	 * @param ctx the parse tree
+	 */
+	void exitForUpdate(PhpParser.ForUpdateContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#switchStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterSwitchStatement(PhpParser.SwitchStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#switchStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitSwitchStatement(PhpParser.SwitchStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#switchBlock}.
+	 * @param ctx the parse tree
+	 */
+	void enterSwitchBlock(PhpParser.SwitchBlockContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#switchBlock}.
+	 * @param ctx the parse tree
+	 */
+	void exitSwitchBlock(PhpParser.SwitchBlockContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#breakStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterBreakStatement(PhpParser.BreakStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#breakStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitBreakStatement(PhpParser.BreakStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#continueStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterContinueStatement(PhpParser.ContinueStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#continueStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitContinueStatement(PhpParser.ContinueStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#returnStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterReturnStatement(PhpParser.ReturnStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#returnStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitReturnStatement(PhpParser.ReturnStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#expressionStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterExpressionStatement(PhpParser.ExpressionStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#expressionStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitExpressionStatement(PhpParser.ExpressionStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#unsetStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterUnsetStatement(PhpParser.UnsetStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#unsetStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitUnsetStatement(PhpParser.UnsetStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#foreachStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterForeachStatement(PhpParser.ForeachStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#foreachStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitForeachStatement(PhpParser.ForeachStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#tryCatchFinally}.
+	 * @param ctx the parse tree
+	 */
+	void enterTryCatchFinally(PhpParser.TryCatchFinallyContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#tryCatchFinally}.
+	 * @param ctx the parse tree
+	 */
+	void exitTryCatchFinally(PhpParser.TryCatchFinallyContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#catchClause}.
+	 * @param ctx the parse tree
+	 */
+	void enterCatchClause(PhpParser.CatchClauseContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#catchClause}.
+	 * @param ctx the parse tree
+	 */
+	void exitCatchClause(PhpParser.CatchClauseContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#finallyStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterFinallyStatement(PhpParser.FinallyStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#finallyStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitFinallyStatement(PhpParser.FinallyStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#throwStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterThrowStatement(PhpParser.ThrowStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#throwStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitThrowStatement(PhpParser.ThrowStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#gotoStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterGotoStatement(PhpParser.GotoStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#gotoStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitGotoStatement(PhpParser.GotoStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#declareStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterDeclareStatement(PhpParser.DeclareStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#declareStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitDeclareStatement(PhpParser.DeclareStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#inlineHtmlStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterInlineHtmlStatement(PhpParser.InlineHtmlStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#inlineHtmlStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitInlineHtmlStatement(PhpParser.InlineHtmlStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#declareList}.
+	 * @param ctx the parse tree
+	 */
+	void enterDeclareList(PhpParser.DeclareListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#declareList}.
+	 * @param ctx the parse tree
+	 */
+	void exitDeclareList(PhpParser.DeclareListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#directive}.
+	 * @param ctx the parse tree
+	 */
+	void enterDirective(PhpParser.DirectiveContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#directive}.
+	 * @param ctx the parse tree
+	 */
+	void exitDirective(PhpParser.DirectiveContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#formalParameterList}.
+	 * @param ctx the parse tree
+	 */
+	void enterFormalParameterList(PhpParser.FormalParameterListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#formalParameterList}.
+	 * @param ctx the parse tree
+	 */
+	void exitFormalParameterList(PhpParser.FormalParameterListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#formalParameter}.
+	 * @param ctx the parse tree
+	 */
+	void enterFormalParameter(PhpParser.FormalParameterContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#formalParameter}.
+	 * @param ctx the parse tree
+	 */
+	void exitFormalParameter(PhpParser.FormalParameterContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#typeHint}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeHint(PhpParser.TypeHintContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#typeHint}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeHint(PhpParser.TypeHintContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#globalStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterGlobalStatement(PhpParser.GlobalStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#globalStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitGlobalStatement(PhpParser.GlobalStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#globalVar}.
+	 * @param ctx the parse tree
+	 */
+	void enterGlobalVar(PhpParser.GlobalVarContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#globalVar}.
+	 * @param ctx the parse tree
+	 */
+	void exitGlobalVar(PhpParser.GlobalVarContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#echoStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterEchoStatement(PhpParser.EchoStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#echoStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitEchoStatement(PhpParser.EchoStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#staticVariableStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterStaticVariableStatement(PhpParser.StaticVariableStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#staticVariableStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitStaticVariableStatement(PhpParser.StaticVariableStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#classStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterClassStatement(PhpParser.ClassStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#classStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitClassStatement(PhpParser.ClassStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#traitAdaptations}.
+	 * @param ctx the parse tree
+	 */
+	void enterTraitAdaptations(PhpParser.TraitAdaptationsContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#traitAdaptations}.
+	 * @param ctx the parse tree
+	 */
+	void exitTraitAdaptations(PhpParser.TraitAdaptationsContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#traitAdaptationStatement}.
+	 * @param ctx the parse tree
+	 */
+	void enterTraitAdaptationStatement(PhpParser.TraitAdaptationStatementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#traitAdaptationStatement}.
+	 * @param ctx the parse tree
+	 */
+	void exitTraitAdaptationStatement(PhpParser.TraitAdaptationStatementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#traitPrecedence}.
+	 * @param ctx the parse tree
+	 */
+	void enterTraitPrecedence(PhpParser.TraitPrecedenceContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#traitPrecedence}.
+	 * @param ctx the parse tree
+	 */
+	void exitTraitPrecedence(PhpParser.TraitPrecedenceContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#traitAlias}.
+	 * @param ctx the parse tree
+	 */
+	void enterTraitAlias(PhpParser.TraitAliasContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#traitAlias}.
+	 * @param ctx the parse tree
+	 */
+	void exitTraitAlias(PhpParser.TraitAliasContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#traitMethodReference}.
+	 * @param ctx the parse tree
+	 */
+	void enterTraitMethodReference(PhpParser.TraitMethodReferenceContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#traitMethodReference}.
+	 * @param ctx the parse tree
+	 */
+	void exitTraitMethodReference(PhpParser.TraitMethodReferenceContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#baseCtorCall}.
+	 * @param ctx the parse tree
+	 */
+	void enterBaseCtorCall(PhpParser.BaseCtorCallContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#baseCtorCall}.
+	 * @param ctx the parse tree
+	 */
+	void exitBaseCtorCall(PhpParser.BaseCtorCallContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#returnTypeDecl}.
+	 * @param ctx the parse tree
+	 */
+	void enterReturnTypeDecl(PhpParser.ReturnTypeDeclContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#returnTypeDecl}.
+	 * @param ctx the parse tree
+	 */
+	void exitReturnTypeDecl(PhpParser.ReturnTypeDeclContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#methodBody}.
+	 * @param ctx the parse tree
+	 */
+	void enterMethodBody(PhpParser.MethodBodyContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#methodBody}.
+	 * @param ctx the parse tree
+	 */
+	void exitMethodBody(PhpParser.MethodBodyContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#propertyModifiers}.
+	 * @param ctx the parse tree
+	 */
+	void enterPropertyModifiers(PhpParser.PropertyModifiersContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#propertyModifiers}.
+	 * @param ctx the parse tree
+	 */
+	void exitPropertyModifiers(PhpParser.PropertyModifiersContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#memberModifiers}.
+	 * @param ctx the parse tree
+	 */
+	void enterMemberModifiers(PhpParser.MemberModifiersContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#memberModifiers}.
+	 * @param ctx the parse tree
+	 */
+	void exitMemberModifiers(PhpParser.MemberModifiersContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#variableInitializer}.
+	 * @param ctx the parse tree
+	 */
+	void enterVariableInitializer(PhpParser.VariableInitializerContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#variableInitializer}.
+	 * @param ctx the parse tree
+	 */
+	void exitVariableInitializer(PhpParser.VariableInitializerContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#identifierInitializer}.
+	 * @param ctx the parse tree
+	 */
+	void enterIdentifierInitializer(PhpParser.IdentifierInitializerContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#identifierInitializer}.
+	 * @param ctx the parse tree
+	 */
+	void exitIdentifierInitializer(PhpParser.IdentifierInitializerContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#globalConstantDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterGlobalConstantDeclaration(PhpParser.GlobalConstantDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#globalConstantDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitGlobalConstantDeclaration(PhpParser.GlobalConstantDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#enumDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterEnumDeclaration(PhpParser.EnumDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#enumDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitEnumDeclaration(PhpParser.EnumDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#enumItem}.
+	 * @param ctx the parse tree
+	 */
+	void enterEnumItem(PhpParser.EnumItemContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#enumItem}.
+	 * @param ctx the parse tree
+	 */
+	void exitEnumItem(PhpParser.EnumItemContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#expressionList}.
+	 * @param ctx the parse tree
+	 */
+	void enterExpressionList(PhpParser.ExpressionListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#expressionList}.
+	 * @param ctx the parse tree
+	 */
+	void exitExpressionList(PhpParser.ExpressionListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#parentheses}.
+	 * @param ctx the parse tree
+	 */
+	void enterParentheses(PhpParser.ParenthesesContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#parentheses}.
+	 * @param ctx the parse tree
+	 */
+	void exitParentheses(PhpParser.ParenthesesContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code ChainExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterChainExpression(PhpParser.ChainExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code ChainExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitChainExpression(PhpParser.ChainExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code SpecialWordExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterSpecialWordExpression(PhpParser.SpecialWordExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code SpecialWordExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitSpecialWordExpression(PhpParser.SpecialWordExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code ArrayCreationExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterArrayCreationExpression(PhpParser.ArrayCreationExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code ArrayCreationExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitArrayCreationExpression(PhpParser.ArrayCreationExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code BackQuoteStringExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterBackQuoteStringExpression(PhpParser.BackQuoteStringExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code BackQuoteStringExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitBackQuoteStringExpression(PhpParser.BackQuoteStringExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code MatchExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterMatchExpression(PhpParser.MatchExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code MatchExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitMatchExpression(PhpParser.MatchExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code LogicalExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterLogicalExpression(PhpParser.LogicalExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code LogicalExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitLogicalExpression(PhpParser.LogicalExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code PrintExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterPrintExpression(PhpParser.PrintExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code PrintExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitPrintExpression(PhpParser.PrintExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code AssignmentExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterAssignmentExpression(PhpParser.AssignmentExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code AssignmentExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitAssignmentExpression(PhpParser.AssignmentExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code PostfixIncDecExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterPostfixIncDecExpression(PhpParser.PostfixIncDecExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code PostfixIncDecExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitPostfixIncDecExpression(PhpParser.PostfixIncDecExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code CloneExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterCloneExpression(PhpParser.CloneExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code CloneExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitCloneExpression(PhpParser.CloneExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code UnaryOperatorExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterUnaryOperatorExpression(PhpParser.UnaryOperatorExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code UnaryOperatorExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitUnaryOperatorExpression(PhpParser.UnaryOperatorExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code NewExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterNewExpression(PhpParser.NewExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code NewExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitNewExpression(PhpParser.NewExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code ParenthesisExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterParenthesisExpression(PhpParser.ParenthesisExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code ParenthesisExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitParenthesisExpression(PhpParser.ParenthesisExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code SpaceshipExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterSpaceshipExpression(PhpParser.SpaceshipExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code SpaceshipExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitSpaceshipExpression(PhpParser.SpaceshipExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code ConditionalExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterConditionalExpression(PhpParser.ConditionalExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code ConditionalExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitConditionalExpression(PhpParser.ConditionalExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code NullCoalescingExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterNullCoalescingExpression(PhpParser.NullCoalescingExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code NullCoalescingExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitNullCoalescingExpression(PhpParser.NullCoalescingExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code ArithmeticExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterArithmeticExpression(PhpParser.ArithmeticExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code ArithmeticExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitArithmeticExpression(PhpParser.ArithmeticExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code IndexerExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterIndexerExpression(PhpParser.IndexerExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code IndexerExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitIndexerExpression(PhpParser.IndexerExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code ScalarExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterScalarExpression(PhpParser.ScalarExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code ScalarExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitScalarExpression(PhpParser.ScalarExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code PrefixIncDecExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterPrefixIncDecExpression(PhpParser.PrefixIncDecExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code PrefixIncDecExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitPrefixIncDecExpression(PhpParser.PrefixIncDecExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code ComparisonExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterComparisonExpression(PhpParser.ComparisonExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code ComparisonExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitComparisonExpression(PhpParser.ComparisonExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code CastExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterCastExpression(PhpParser.CastExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code CastExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitCastExpression(PhpParser.CastExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code InstanceOfExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterInstanceOfExpression(PhpParser.InstanceOfExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code InstanceOfExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitInstanceOfExpression(PhpParser.InstanceOfExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code ArrayDestructExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterArrayDestructExpression(PhpParser.ArrayDestructExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code ArrayDestructExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitArrayDestructExpression(PhpParser.ArrayDestructExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code LambdaFunctionExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterLambdaFunctionExpression(PhpParser.LambdaFunctionExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code LambdaFunctionExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitLambdaFunctionExpression(PhpParser.LambdaFunctionExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code BitwiseExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterBitwiseExpression(PhpParser.BitwiseExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code BitwiseExpression}
+	 * labeled alternative in {@link PhpParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitBitwiseExpression(PhpParser.BitwiseExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#assignable}.
+	 * @param ctx the parse tree
+	 */
+	void enterAssignable(PhpParser.AssignableContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#assignable}.
+	 * @param ctx the parse tree
+	 */
+	void exitAssignable(PhpParser.AssignableContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#arrayCreation}.
+	 * @param ctx the parse tree
+	 */
+	void enterArrayCreation(PhpParser.ArrayCreationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#arrayCreation}.
+	 * @param ctx the parse tree
+	 */
+	void exitArrayCreation(PhpParser.ArrayCreationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#arrayDestructuring}.
+	 * @param ctx the parse tree
+	 */
+	void enterArrayDestructuring(PhpParser.ArrayDestructuringContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#arrayDestructuring}.
+	 * @param ctx the parse tree
+	 */
+	void exitArrayDestructuring(PhpParser.ArrayDestructuringContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#indexedDestructItem}.
+	 * @param ctx the parse tree
+	 */
+	void enterIndexedDestructItem(PhpParser.IndexedDestructItemContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#indexedDestructItem}.
+	 * @param ctx the parse tree
+	 */
+	void exitIndexedDestructItem(PhpParser.IndexedDestructItemContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#keyedDestructItem}.
+	 * @param ctx the parse tree
+	 */
+	void enterKeyedDestructItem(PhpParser.KeyedDestructItemContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#keyedDestructItem}.
+	 * @param ctx the parse tree
+	 */
+	void exitKeyedDestructItem(PhpParser.KeyedDestructItemContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#lambdaFunctionExpr}.
+	 * @param ctx the parse tree
+	 */
+	void enterLambdaFunctionExpr(PhpParser.LambdaFunctionExprContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#lambdaFunctionExpr}.
+	 * @param ctx the parse tree
+	 */
+	void exitLambdaFunctionExpr(PhpParser.LambdaFunctionExprContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#matchExpr}.
+	 * @param ctx the parse tree
+	 */
+	void enterMatchExpr(PhpParser.MatchExprContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#matchExpr}.
+	 * @param ctx the parse tree
+	 */
+	void exitMatchExpr(PhpParser.MatchExprContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#matchItem}.
+	 * @param ctx the parse tree
+	 */
+	void enterMatchItem(PhpParser.MatchItemContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#matchItem}.
+	 * @param ctx the parse tree
+	 */
+	void exitMatchItem(PhpParser.MatchItemContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#newExpr}.
+	 * @param ctx the parse tree
+	 */
+	void enterNewExpr(PhpParser.NewExprContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#newExpr}.
+	 * @param ctx the parse tree
+	 */
+	void exitNewExpr(PhpParser.NewExprContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#assignmentOperator}.
+	 * @param ctx the parse tree
+	 */
+	void enterAssignmentOperator(PhpParser.AssignmentOperatorContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#assignmentOperator}.
+	 * @param ctx the parse tree
+	 */
+	void exitAssignmentOperator(PhpParser.AssignmentOperatorContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#yieldExpression}.
+	 * @param ctx the parse tree
+	 */
+	void enterYieldExpression(PhpParser.YieldExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#yieldExpression}.
+	 * @param ctx the parse tree
+	 */
+	void exitYieldExpression(PhpParser.YieldExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#arrayItemList}.
+	 * @param ctx the parse tree
+	 */
+	void enterArrayItemList(PhpParser.ArrayItemListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#arrayItemList}.
+	 * @param ctx the parse tree
+	 */
+	void exitArrayItemList(PhpParser.ArrayItemListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#arrayItem}.
+	 * @param ctx the parse tree
+	 */
+	void enterArrayItem(PhpParser.ArrayItemContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#arrayItem}.
+	 * @param ctx the parse tree
+	 */
+	void exitArrayItem(PhpParser.ArrayItemContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#lambdaFunctionUseVars}.
+	 * @param ctx the parse tree
+	 */
+	void enterLambdaFunctionUseVars(PhpParser.LambdaFunctionUseVarsContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#lambdaFunctionUseVars}.
+	 * @param ctx the parse tree
+	 */
+	void exitLambdaFunctionUseVars(PhpParser.LambdaFunctionUseVarsContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#lambdaFunctionUseVar}.
+	 * @param ctx the parse tree
+	 */
+	void enterLambdaFunctionUseVar(PhpParser.LambdaFunctionUseVarContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#lambdaFunctionUseVar}.
+	 * @param ctx the parse tree
+	 */
+	void exitLambdaFunctionUseVar(PhpParser.LambdaFunctionUseVarContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#qualifiedStaticTypeRef}.
+	 * @param ctx the parse tree
+	 */
+	void enterQualifiedStaticTypeRef(PhpParser.QualifiedStaticTypeRefContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#qualifiedStaticTypeRef}.
+	 * @param ctx the parse tree
+	 */
+	void exitQualifiedStaticTypeRef(PhpParser.QualifiedStaticTypeRefContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#typeRef}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeRef(PhpParser.TypeRefContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#typeRef}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeRef(PhpParser.TypeRefContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#anonymousClass}.
+	 * @param ctx the parse tree
+	 */
+	void enterAnonymousClass(PhpParser.AnonymousClassContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#anonymousClass}.
+	 * @param ctx the parse tree
+	 */
+	void exitAnonymousClass(PhpParser.AnonymousClassContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#indirectTypeRef}.
+	 * @param ctx the parse tree
+	 */
+	void enterIndirectTypeRef(PhpParser.IndirectTypeRefContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#indirectTypeRef}.
+	 * @param ctx the parse tree
+	 */
+	void exitIndirectTypeRef(PhpParser.IndirectTypeRefContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#qualifiedNamespaceName}.
+	 * @param ctx the parse tree
+	 */
+	void enterQualifiedNamespaceName(PhpParser.QualifiedNamespaceNameContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#qualifiedNamespaceName}.
+	 * @param ctx the parse tree
+	 */
+	void exitQualifiedNamespaceName(PhpParser.QualifiedNamespaceNameContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#namespaceNameList}.
+	 * @param ctx the parse tree
+	 */
+	void enterNamespaceNameList(PhpParser.NamespaceNameListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#namespaceNameList}.
+	 * @param ctx the parse tree
+	 */
+	void exitNamespaceNameList(PhpParser.NamespaceNameListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#namespaceNameTail}.
+	 * @param ctx the parse tree
+	 */
+	void enterNamespaceNameTail(PhpParser.NamespaceNameTailContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#namespaceNameTail}.
+	 * @param ctx the parse tree
+	 */
+	void exitNamespaceNameTail(PhpParser.NamespaceNameTailContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#qualifiedNamespaceNameList}.
+	 * @param ctx the parse tree
+	 */
+	void enterQualifiedNamespaceNameList(PhpParser.QualifiedNamespaceNameListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#qualifiedNamespaceNameList}.
+	 * @param ctx the parse tree
+	 */
+	void exitQualifiedNamespaceNameList(PhpParser.QualifiedNamespaceNameListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#arguments}.
+	 * @param ctx the parse tree
+	 */
+	void enterArguments(PhpParser.ArgumentsContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#arguments}.
+	 * @param ctx the parse tree
+	 */
+	void exitArguments(PhpParser.ArgumentsContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#actualArgument}.
+	 * @param ctx the parse tree
+	 */
+	void enterActualArgument(PhpParser.ActualArgumentContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#actualArgument}.
+	 * @param ctx the parse tree
+	 */
+	void exitActualArgument(PhpParser.ActualArgumentContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#argumentName}.
+	 * @param ctx the parse tree
+	 */
+	void enterArgumentName(PhpParser.ArgumentNameContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#argumentName}.
+	 * @param ctx the parse tree
+	 */
+	void exitArgumentName(PhpParser.ArgumentNameContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#constantInitializer}.
+	 * @param ctx the parse tree
+	 */
+	void enterConstantInitializer(PhpParser.ConstantInitializerContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#constantInitializer}.
+	 * @param ctx the parse tree
+	 */
+	void exitConstantInitializer(PhpParser.ConstantInitializerContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#constant}.
+	 * @param ctx the parse tree
+	 */
+	void enterConstant(PhpParser.ConstantContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#constant}.
+	 * @param ctx the parse tree
+	 */
+	void exitConstant(PhpParser.ConstantContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#literalConstant}.
+	 * @param ctx the parse tree
+	 */
+	void enterLiteralConstant(PhpParser.LiteralConstantContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#literalConstant}.
+	 * @param ctx the parse tree
+	 */
+	void exitLiteralConstant(PhpParser.LiteralConstantContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#numericConstant}.
+	 * @param ctx the parse tree
+	 */
+	void enterNumericConstant(PhpParser.NumericConstantContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#numericConstant}.
+	 * @param ctx the parse tree
+	 */
+	void exitNumericConstant(PhpParser.NumericConstantContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#classConstant}.
+	 * @param ctx the parse tree
+	 */
+	void enterClassConstant(PhpParser.ClassConstantContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#classConstant}.
+	 * @param ctx the parse tree
+	 */
+	void exitClassConstant(PhpParser.ClassConstantContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#stringConstant}.
+	 * @param ctx the parse tree
+	 */
+	void enterStringConstant(PhpParser.StringConstantContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#stringConstant}.
+	 * @param ctx the parse tree
+	 */
+	void exitStringConstant(PhpParser.StringConstantContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#string}.
+	 * @param ctx the parse tree
+	 */
+	void enterString(PhpParser.StringContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#string}.
+	 * @param ctx the parse tree
+	 */
+	void exitString(PhpParser.StringContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#interpolatedStringPart}.
+	 * @param ctx the parse tree
+	 */
+	void enterInterpolatedStringPart(PhpParser.InterpolatedStringPartContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#interpolatedStringPart}.
+	 * @param ctx the parse tree
+	 */
+	void exitInterpolatedStringPart(PhpParser.InterpolatedStringPartContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#chainList}.
+	 * @param ctx the parse tree
+	 */
+	void enterChainList(PhpParser.ChainListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#chainList}.
+	 * @param ctx the parse tree
+	 */
+	void exitChainList(PhpParser.ChainListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#chain}.
+	 * @param ctx the parse tree
+	 */
+	void enterChain(PhpParser.ChainContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#chain}.
+	 * @param ctx the parse tree
+	 */
+	void exitChain(PhpParser.ChainContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#chainOrigin}.
+	 * @param ctx the parse tree
+	 */
+	void enterChainOrigin(PhpParser.ChainOriginContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#chainOrigin}.
+	 * @param ctx the parse tree
+	 */
+	void exitChainOrigin(PhpParser.ChainOriginContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#memberAccess}.
+	 * @param ctx the parse tree
+	 */
+	void enterMemberAccess(PhpParser.MemberAccessContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#memberAccess}.
+	 * @param ctx the parse tree
+	 */
+	void exitMemberAccess(PhpParser.MemberAccessContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#functionCall}.
+	 * @param ctx the parse tree
+	 */
+	void enterFunctionCall(PhpParser.FunctionCallContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#functionCall}.
+	 * @param ctx the parse tree
+	 */
+	void exitFunctionCall(PhpParser.FunctionCallContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#functionCallName}.
+	 * @param ctx the parse tree
+	 */
+	void enterFunctionCallName(PhpParser.FunctionCallNameContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#functionCallName}.
+	 * @param ctx the parse tree
+	 */
+	void exitFunctionCallName(PhpParser.FunctionCallNameContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#actualArguments}.
+	 * @param ctx the parse tree
+	 */
+	void enterActualArguments(PhpParser.ActualArgumentsContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#actualArguments}.
+	 * @param ctx the parse tree
+	 */
+	void exitActualArguments(PhpParser.ActualArgumentsContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#chainBase}.
+	 * @param ctx the parse tree
+	 */
+	void enterChainBase(PhpParser.ChainBaseContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#chainBase}.
+	 * @param ctx the parse tree
+	 */
+	void exitChainBase(PhpParser.ChainBaseContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#keyedFieldName}.
+	 * @param ctx the parse tree
+	 */
+	void enterKeyedFieldName(PhpParser.KeyedFieldNameContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#keyedFieldName}.
+	 * @param ctx the parse tree
+	 */
+	void exitKeyedFieldName(PhpParser.KeyedFieldNameContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#keyedSimpleFieldName}.
+	 * @param ctx the parse tree
+	 */
+	void enterKeyedSimpleFieldName(PhpParser.KeyedSimpleFieldNameContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#keyedSimpleFieldName}.
+	 * @param ctx the parse tree
+	 */
+	void exitKeyedSimpleFieldName(PhpParser.KeyedSimpleFieldNameContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#keyedVariable}.
+	 * @param ctx the parse tree
+	 */
+	void enterKeyedVariable(PhpParser.KeyedVariableContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#keyedVariable}.
+	 * @param ctx the parse tree
+	 */
+	void exitKeyedVariable(PhpParser.KeyedVariableContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#squareCurlyExpression}.
+	 * @param ctx the parse tree
+	 */
+	void enterSquareCurlyExpression(PhpParser.SquareCurlyExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#squareCurlyExpression}.
+	 * @param ctx the parse tree
+	 */
+	void exitSquareCurlyExpression(PhpParser.SquareCurlyExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#assignmentList}.
+	 * @param ctx the parse tree
+	 */
+	void enterAssignmentList(PhpParser.AssignmentListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#assignmentList}.
+	 * @param ctx the parse tree
+	 */
+	void exitAssignmentList(PhpParser.AssignmentListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#assignmentListElement}.
+	 * @param ctx the parse tree
+	 */
+	void enterAssignmentListElement(PhpParser.AssignmentListElementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#assignmentListElement}.
+	 * @param ctx the parse tree
+	 */
+	void exitAssignmentListElement(PhpParser.AssignmentListElementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#modifier}.
+	 * @param ctx the parse tree
+	 */
+	void enterModifier(PhpParser.ModifierContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#modifier}.
+	 * @param ctx the parse tree
+	 */
+	void exitModifier(PhpParser.ModifierContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#identifier}.
+	 * @param ctx the parse tree
+	 */
+	void enterIdentifier(PhpParser.IdentifierContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#identifier}.
+	 * @param ctx the parse tree
+	 */
+	void exitIdentifier(PhpParser.IdentifierContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#memberModifier}.
+	 * @param ctx the parse tree
+	 */
+	void enterMemberModifier(PhpParser.MemberModifierContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#memberModifier}.
+	 * @param ctx the parse tree
+	 */
+	void exitMemberModifier(PhpParser.MemberModifierContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#magicConstant}.
+	 * @param ctx the parse tree
+	 */
+	void enterMagicConstant(PhpParser.MagicConstantContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#magicConstant}.
+	 * @param ctx the parse tree
+	 */
+	void exitMagicConstant(PhpParser.MagicConstantContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#magicMethod}.
+	 * @param ctx the parse tree
+	 */
+	void enterMagicMethod(PhpParser.MagicMethodContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#magicMethod}.
+	 * @param ctx the parse tree
+	 */
+	void exitMagicMethod(PhpParser.MagicMethodContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#primitiveType}.
+	 * @param ctx the parse tree
+	 */
+	void enterPrimitiveType(PhpParser.PrimitiveTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#primitiveType}.
+	 * @param ctx the parse tree
+	 */
+	void exitPrimitiveType(PhpParser.PrimitiveTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link PhpParser#castOperation}.
+	 * @param ctx the parse tree
+	 */
+	void enterCastOperation(PhpParser.CastOperationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link PhpParser#castOperation}.
+	 * @param ctx the parse tree
+	 */
+	void exitCastOperation(PhpParser.CastOperationContext ctx);
+}
\ No newline at end of file
diff --git a/app/src/main/java/githubsqlfinder/App.java b/app/src/main/java/githubsqlfinder/App.java
index eb4d9657ff2b79bfdf2e9ea12917d464fb13626a..620358521db1815cd6902355e0119487cb3027d7 100644
--- a/app/src/main/java/githubsqlfinder/App.java
+++ b/app/src/main/java/githubsqlfinder/App.java
@@ -1,20 +1,14 @@
-/*
- * This Java source file was generated by the Gradle 'init' task.
- */
 package githubsqlfinder;
 
 import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
 import java.util.List;
-import java.util.Scanner;
-import java.util.UUID;
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import org.antlr.v4.runtime.*;
 import org.antlr.v4.runtime.tree.*;
@@ -23,48 +17,136 @@ import com.google.cloud.bigquery.FieldValueList;
 import com.google.cloud.bigquery.TableResult;
 
 import antlr.*;
+import antlr.PhpParser.ArithmeticExpressionContext;
+import antlr.PhpParser.ChainExpressionContext;
+import antlr.PhpParser.StringContext;
 
 public class App {
 
+    static List<String> stringStatements = new ArrayList<>();
+    static Map<String, List<String>> stringStatementsWithParts = new HashMap<>();
+    static int paramIndex = 0;
+    static String query = "";
+    static long githubTimeMs = 0;
+    static long antlrTimeMs = 0;
+    static long parsingTreeTimeMs = 0;
+    static int numberOfAddedQueries = 0;
+    static int numberOfAddedQueriesMySql = 0;
+    static int numberOfAddedQueriesPlSql = 0;
+    static int numberOfAddedQueriesPostgreSQL = 0;
+    static int numberOfAddedQueriesTSql = 0;
+    static long timeMs = 0;
+
     public static void main(String[] args) throws Exception {
 
-        JDBC db = new JDBC();
-        Scanner scanner = new Scanner(System.in);
-
-        System.out.println("Do you want to use: ");
-        System.out.println("1. Example files");
-        System.out.println("2. Github files");
-        System.out.println("3. See database");
-        System.out.println("Please enter option number: ");
-
-        int mode = 0;
-        while (mode != 1 && mode != 2 && mode != 3) {
-            mode = scanner.nextInt();
-            if (mode != 1 && mode != 2 && mode != 3) {
-                System.out.println("Invalid input. Please enter a valid number: ");
+        long sTime = System.nanoTime();
+
+        int numberOfGithubFilesToSearch = 100;
+        int batchSize = 100;
+        int mode = 2;
+        int offset = 0;
+        int sample = 1;
+
+        if (args.length > 0) {
+            //set number of files from github that should be searched
+            try {
+                numberOfGithubFilesToSearch = Integer.parseInt(args[0]);
+            } catch (NumberFormatException e) {
+                System.err.println("The first parameter (number of files to process) was incorrect");
+                return;
             }
+           
+        }
+
+        if (args.length > 1) {
+            //set the batch size to process
+            try {
+                batchSize = Integer.parseInt(args[1]);
+            } catch (NumberFormatException e) {
+                System.err.println("The second parameter (the size of the batch) was incorrect");
+                return;
+            }    
+        }
+
+        if (args.length > 2) {
+            //set the batch size to process
+            try {
+                mode = Integer.parseInt(args[2]);
+            } catch (NumberFormatException e) {
+                System.err.println("The third parameter (mode) was incorrect");
+                return;
+            }    
+        }
+
+        if (args.length > 3) {
+            //set the batch size to process
+            try {
+                offset = Integer.parseInt(args[3]);
+            } catch (NumberFormatException e) {
+                System.err.println("The third parameter (offset) was incorrect");
+                return;
+            }    
         }
 
+        if (args.length > 4) {
+            //set the batch size to process
+            try {
+                sample = Integer.parseInt(args[4]);
+            } catch (NumberFormatException e) {
+                System.err.println("The fourth parameter (sample data) was incorrect");
+                return;
+            }    
+        }
+
+        //
+        System.out.println("Number of files to process: " + numberOfGithubFilesToSearch);
+        System.out.println("Batch size: " + batchSize);
+        System.out.println("Mode (1 - Example files, 2 - Github, 3 - Clear DB): " + mode);
+        System.out.println("Data (1 - Sample data, 2 - Real data): " + sample);
+        System.out.println("offset: " + offset);
+        
+        JDBC db = new JDBC();
         boolean repeatCycle = true;
         String input = "";
 
         
         if (mode == 1) {
-            for (int i = 0; i < 10; i++) {
-                String fileName = "example" + (i + 1) + ".txt";
-                Path path = Paths.get(App.class.getClassLoader().getResource(fileName).toURI());
+            //example files
+            int maxFile = 3;
+
+            for (int i = 0; i < maxFile; i++) {
+                String filePath = "example" + (i + 1) + ".txt";
+                Path path = Paths.get(App.class.getClassLoader().getResource(filePath).toURI());
 
                 input = Files.readString(path);
 
-                runAntlr(input, "example", fileName);
+                runPhpAntlr(input, "example", filePath);
+
+                for (String query : stringStatements) {
+                    if (isValidQuery(query)) {
+                        runAntlr(query.replaceAll("\\\\", ""), "example", filePath);
+                    }
+                }
             }
         } else if (mode == 2) {
             //github
 
+            int step = 0;
+            int index = 0;
+            int originalBatchSize = batchSize;
+
+            System.out.println("Processed files / All files");
             while (repeatCycle) {
                 GithubFinder githubFinder = new GithubFinder();
 
-                TableResult result = githubFinder.getFilesFromGithub();
+                if ((step + 1) * batchSize >= numberOfGithubFilesToSearch) {
+                    batchSize = numberOfGithubFilesToSearch - (step * batchSize);
+                }
+                long startTime = System.nanoTime();
+                TableResult result = githubFinder.getFilesFromGithub(batchSize, step, originalBatchSize, offset, sample);
+                long endTime = System.nanoTime();
+
+                githubTimeMs += (endTime - startTime) / 1_000_000;
 
                 for (FieldValueList row : result.iterateAll()) {
 
@@ -72,78 +154,187 @@ public class App {
                     String repoName = row.get("repo_name").getStringValue();
                     String filePath = row.get("path").getStringValue();
 
-                    runAntlr(input, repoName, filePath);
-                }
+                    runPhpAntlr(input, repoName, filePath);
 
-                System.out.println("Do you want to parse another 10 github files: ");
-                System.out.println("1. Yes");
-                System.out.println("2. No");
-                System.out.println("Please enter option number: ");
-                mode = 0;
-                while (mode != 1 && mode != 2) {
-                    mode = scanner.nextInt();
-                    if (mode != 1 && mode != 2) {
-                        System.out.println("Invalid input. Please enter a valid number: ");
+                    for (String query : stringStatements) {
+                        if (isValidQuery(query)) {
+                            runAntlr(query.replaceAll("\\\\", ""), repoName, filePath);
+                        }                        
                     }
+                    index++;
+                    System.out.println("" + index + "/" + numberOfGithubFilesToSearch);
                 }
 
-                if (mode == 2) {
+                step++;
+                if ((step * originalBatchSize) >= numberOfGithubFilesToSearch) {
                     repeatCycle = false;
                 }
+                
             }
+        } else if (mode == 3) {
+            db.deleteDb();
+        }
+        
+        db.showPage(0, true);
+
+        long eTime = System.nanoTime();
+
+        timeMs += (eTime - sTime) / 1_000_000;
+
+        if (mode == 2) {
+            System.out.println("Github requests time in ms: " + githubTimeMs + "(" + String.format("%.2f", ((double) githubTimeMs / timeMs) * 100) + "%)");
+            System.out.println("ANTLR parsing time in ms: " + antlrTimeMs + "(" + String.format("%.2f", ((double) antlrTimeMs / timeMs) * 100) + "%)");
+            System.out.println("Parsing tree string finding: " + parsingTreeTimeMs + "(" + String.format("%.2f", ((double) parsingTreeTimeMs / timeMs) * 100) + "%)");
+            System.out.println("Whole time: " + timeMs);
+            System.out.println("Number of all found queries: " + numberOfAddedQueries + "(from " + numberOfGithubFilesToSearch + " files)");
+            System.out.println("Number of TSql queries: " + numberOfAddedQueriesTSql);
+            System.out.println("Number of Postgre SQL queries: " + numberOfAddedQueriesPostgreSQL);
+            System.out.println("Number of PlSql queries: " + numberOfAddedQueriesPlSql);
+            System.out.println("Number of MySql queries: " + numberOfAddedQueriesMySql);
+            System.out.println("New offset to use for query: " + (numberOfGithubFilesToSearch + offset));
+
         }
+    }
+
+    public static void runPhpAntlr(String input, String repoName, String filePath) {
+        ANTLRInputStream phpInputStream = new ANTLRInputStream(input);
+
+        PhpLexer phpLexer = new PhpLexer(phpInputStream);
+        CommonTokenStream phpTokens = new CommonTokenStream(phpLexer);
+        PhpParser phpParser = new PhpParser(phpTokens);
+
+        phpLexer.removeErrorListeners();
+        phpParser.removeErrorListeners();
         
-        db.showPage(0);
-        boolean exit = false;
-        int index = 0;
-
-        while (!exit) {
-            System.out.println("Do you want to go to (in database): ");
-            System.out.println("1. Next page");
-            System.out.println("2. Previous page");
-            System.out.println("3. Exit");
-            System.out.println("Please enter option number: ");
-            mode = 0;
-            while (mode != 1 && mode != 2 && mode != 3) {
-                mode = scanner.nextInt();
-                if (mode != 1 && mode != 2 && mode != 3) {
-                    System.out.println("Invalid input. Please enter a valid number: ");
+        stringStatements = new ArrayList<>();
+        phpParser.addErrorListener(new DiagnosticErrorListener());
+
+        long startTime = System.nanoTime();
+        ParseTree phpTree = phpParser.phpBlock();
+        long endTime = System.nanoTime();
+
+        antlrTimeMs += (endTime - startTime) / 1_000_000;
+
+        startTime = System.nanoTime();
+        parseTree(phpTree, 0);
+        endTime = System.nanoTime();
+        parsingTreeTimeMs += (endTime - startTime) / 1_000_000;
+    }
+
+    private static void parseTree(ParseTree tree, int index) {
+        if (tree instanceof StringContext) {
+            ParseTree parent = tree.getParent();
+            ArithmeticExpressionContext arithmeticExpressionContext = null;
+
+            while (parent != null && parent.getText().contains(tree.getText())) {
+                if (parent instanceof ArithmeticExpressionContext) {
+                    arithmeticExpressionContext = (ArithmeticExpressionContext) parent;
                 }
+                parent = parent.getParent();
             }
-
-            if (mode == 3) {
-                exit = true;
+            
+            if (arithmeticExpressionContext != null ) {
+                query = "";
+                paramIndex = 0;
+                getParametrizedQuery(arithmeticExpressionContext);
+                if (!query.equals("") && !stringStatements.contains(query)) {
+                    stringStatements.add(query);
+                }
+                arithmeticExpressionContext = null;
+            } else {
+                String text = tree.getText();
+                text = text.replaceAll("\\\\", "");
+                if (((text.startsWith("\'") && text.endsWith("\'")) || (text.startsWith("\"") && text.endsWith("\""))) && text.length() > 1) {
+                    text = text.substring(1, text.length() - 1);
+                }
+                text = replacePHPVariables(text);
+                stringStatements.add(text);
             }
-            if (mode == 1) {
+
+            for (int i = 0; i < tree.getChildCount(); i++) {
                 index++;
-                db.showPage(10 * index);
+                parseTree(tree.getChild(i), index);
             }
-            if (mode == 2 && index != 0) {
-                index--;
-                db.showPage(10 * index);
-            } else if (index == 0 && mode == 2) {
-                System.out.println("You are on the first page.");
+        } else {
+            for (int i = 0; i < tree.getChildCount(); i++) {
+                index++;
+                parseTree(tree.getChild(i), index);
             }
         }
+    }
+
+    public static String replacePHPVariables(String sql) {
+        Pattern pattern = Pattern.compile("(\\$[^\\s]+\\s)|('\\$[^']+')|(\"\\$[^\"]+\")");
+        Matcher matcher = pattern.matcher(sql);
         
+        StringBuffer result = new StringBuffer();
+        int paramIndex = 0;
+
+        while (matcher.find()) {
+            String replacement = ":p" + paramIndex++ + " ";
+            matcher.appendReplacement(result, replacement);
+        }
+        matcher.appendTail(result);
+
+        return result.toString();
+    }
 
-        scanner.close();
+    public static void getParametrizedQuery(ParseTree tree) {
+        if (tree instanceof StringContext) {
+            String text = tree.getText();
+            text = text.replaceAll("\\\\", "");
+            if (((text.startsWith("\'") && text.endsWith("\'")) || (text.startsWith("\"") && text.endsWith("\""))) && text.length() > 1) {
+                text = text.substring(1, text.length() - 1);
+                query += text;
+            } else {
+                query += text;
+            }            
+        } else if (tree instanceof ChainExpressionContext) {
+            query += ":p" + paramIndex;
+            paramIndex++;
+        } else {
+            for (int i = 0; i < tree.getChildCount(); i++) {
+                getParametrizedQuery(tree.getChild(i));
+            }
+        }
     }
 
+    public static boolean isValidQuery(String query) {
+        if (query == null) {
+            return false;
+        }
+    
+        String trimmedQuery = query.trim();
+    
+        String lowerCaseQuery = trimmedQuery.toLowerCase();
+    
+        if (lowerCaseQuery.matches("^(\"select|\'select|select).*from.*")) {
+            return true;
+        }
+    
+        if (lowerCaseQuery.matches("^(\"create table|\'create table|create table).*")) {
+            return true;
+        }
+    
+        return false;
+    }
     public static void runAntlr(String input, String repoName, String filePath) {
         JDBC db = new JDBC();
-        boolean added = false;
+        input = input.toUpperCase();
 
         List<String> plSqlStatements = new ArrayList<>();
         List<String> mySqlStatements = new ArrayList<>();
         List<String> tSqlStatements = new ArrayList<>();
         List<String> postgreSQLStatements = new ArrayList<>();
         ANTLRInputStream plSqlInputStream = new ANTLRInputStream(input);
+        
 
         //PLSql
         PlSqlLexer plSqlLexer = new PlSqlLexer(plSqlInputStream);
         CommonTokenStream plSqlTokens = new CommonTokenStream(plSqlLexer);
         PlSqlParser plSqlParser = new PlSqlParser(plSqlTokens);
+        plSqlLexer.removeErrorListeners();
+        plSqlParser.removeErrorListeners();
         ParseTree plSqlTree = plSqlParser.sql_script();
 
         PlSqlStatementListener plSqlStatementListener = new PlSqlStatementListener(plSqlStatements::add);
@@ -155,6 +346,8 @@ public class App {
             MySqlLexer mySqlLexer = new MySqlLexer(MySqlInputStream);
             CommonTokenStream mySqlTokens = new CommonTokenStream(mySqlLexer);
             MySqlParser mySqlParser = new MySqlParser(mySqlTokens);
+            mySqlLexer.removeErrorListeners();
+            mySqlParser.removeErrorListeners();
             ParseTree mySqlTree = mySqlParser.root();
 
             MySqlStatementListener mySqlStatementListener = new MySqlStatementListener(mySqlStatements::add);
@@ -166,6 +359,8 @@ public class App {
                 TSqlLexer tSqlLexer = new TSqlLexer(TSqlInputStream);
                 CommonTokenStream tSqlTokens = new CommonTokenStream(tSqlLexer);
                 TSqlParser tSqlParser = new TSqlParser(tSqlTokens);
+                tSqlLexer.removeErrorListeners();
+                tSqlParser.removeErrorListeners();
                 ParseTree tSqlTree = tSqlParser.tsql_file();
 
                 TSqlStatementListener tSqlStatementListener = new TSqlStatementListener(tSqlStatements::add);
@@ -177,6 +372,8 @@ public class App {
                     PostgreSQLLexer postgreSQLLexer = new PostgreSQLLexer(PostgreSQLInputStream);
                     CommonTokenStream postgreSQLTokens = new CommonTokenStream(postgreSQLLexer);
                     PostgreSQLParser postgreSQLParser = new PostgreSQLParser(postgreSQLTokens);
+                    postgreSQLLexer.removeErrorListeners();
+                    postgreSQLParser.removeErrorListeners();
                     ParseTree postgreSQLTree = postgreSQLParser.root();       
 
                     PostgreSQLStatementListener postgreSQLStatementListener = new PostgreSQLStatementListener(postgreSQLStatements::add);
@@ -185,46 +382,30 @@ public class App {
                     if (postgreSQLParser.getNumberOfSyntaxErrors() == 0) {
                         for (int i = 0; i < postgreSQLStatements.size(); i++) {
                             db.addSqlInfo(postgreSQLStatements.get(i), repoName, filePath, "POSTGRE SQL");
-                            added = true;
+                            numberOfAddedQueries++;
+                            numberOfAddedQueriesPostgreSQL++;
                         }
                     }
                 } else {
                     for (int i = 0; i < tSqlStatements.size(); i++) {
                         db.addSqlInfo(tSqlStatements.get(i), repoName, filePath, "TSQL");
-                        added = true;
+                        numberOfAddedQueries++;
+                        numberOfAddedQueriesTSql++;
                     }
                 }
             } else {
                 for (int i = 0; i < mySqlStatements.size(); i++) {
                     db.addSqlInfo(mySqlStatements.get(i), repoName, filePath, "MYSQL");
-                    added = true;
+                    numberOfAddedQueries++;
+                    numberOfAddedQueriesMySql++;
                 }
             }
         } else {
             for (int i = 0; i < plSqlStatements.size(); i++) {
-                db.addSqlInfo(plSqlStatements.get(i), "", "", "PROB PLSQL");
-                added = true;
-            }
-        }
-
-        if (!added) {
-            ArrayList<List<String>> lists = new ArrayList<>();
-            lists.add(plSqlStatements);
-            lists.add(mySqlStatements);
-            lists.add(tSqlStatements);
-            lists.add(postgreSQLStatements);
-
-            Collections.sort(lists, Comparator.comparingInt(List::size));
-
-            for (int i = 0; i < lists.get(0).size(); i++) {
-                db.addSqlInfo(lists.get(0).get(i), repoName, filePath, "NOT KNOWN");
-                added = true;
+                db.addSqlInfo(plSqlStatements.get(i), repoName, filePath, "PLSQL");
+                numberOfAddedQueries++;
+                numberOfAddedQueriesPlSql++;
             }
         }
-
-        System.out.println(plSqlStatements.toString());
-        System.out.println(mySqlStatements.toString());
-        System.out.println(tSqlStatements.toString());
-        System.out.println(postgreSQLStatements.toString());
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/githubsqlfinder/GithubFinder.java b/app/src/main/java/githubsqlfinder/GithubFinder.java
index 50260247e54d878b50673fc998050502b23e3a68..15f54baeea7c91124df32238babf62043735265b 100644
--- a/app/src/main/java/githubsqlfinder/GithubFinder.java
+++ b/app/src/main/java/githubsqlfinder/GithubFinder.java
@@ -14,38 +14,48 @@ import java.util.UUID;
 
 public class GithubFinder {
 
-    public TableResult getFilesFromGithub() {
+    public TableResult getFilesFromGithub(int batchSize, int step, int originalBatchSize, int offset, int sample) {
         BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
+
+        String sqlFilesQuery = "select sample_files.id, sample_files.path, sample_contents.content, sample_files.repo_name "
+        + "from bigquery-public-data.github_repos.sample_files as sample_files "
+        + "join bigquery-public-data.github_repos.sample_contents as sample_contents on sample_files.id = sample_contents.id "
+        + "where sample_files.path like '%.sql' limit 10;";
         
+        String phpFilesQuery = "select path, repo_name, content " + 
+                        "from bigquery-public-data.github_repos.files as files " + 
+                        "join bigquery-public-data.github_repos.contents as contents on files.id = contents.id " + 
+                        "where files.path like '%.php' " + 
+                        "and (contents.content like '%select%from%' or contents.content like '%create table%') order by repo_name limit " + batchSize + " offset " + (offset + (step * originalBatchSize)) +";";
+
+        if (sample == 1) {
+            phpFilesQuery = "select path, repo_name, content " + 
+                        "from bigquery-public-data.github_repos.sample_files as sample_files " + 
+                        "join bigquery-public-data.github_repos.sample_contents as sample_contents on sample_files.id = sample_contents.id " + 
+                        "where sample_files.path like '%.php' " + 
+                        "and (sample_contents.content like '%select%from%' or sample_contents.content like '%create table%') order by repo_name limit " + batchSize + " offset " + (offset + (step * originalBatchSize)) +";";
+        }
+
+        System.out.println("BigQuery: " + phpFilesQuery);
+
         QueryJobConfiguration queryConfig =
-            QueryJobConfiguration.newBuilder(
-                    "select sample_files.id, sample_files.path, sample_contents.content, sample_files.repo_name "
-                    + "from bigquery-public-data.github_repos.sample_files as sample_files "
-                    + "join bigquery-public-data.github_repos.sample_contents as sample_contents on sample_files.id = sample_contents.id "
-                    + "where sample_files.path like '%.sql' limit 10;")
-                .build();
+            QueryJobConfiguration.newBuilder(phpFilesQuery).build();
 
-        // Create a job ID so that we can safely retry.
         JobId jobId = JobId.of(UUID.randomUUID().toString());
         Job queryJob = bigquery.create(JobInfo.newBuilder(queryConfig).setJobId(jobId).build());
 
-        // Wait for the query to complete.
         try {
             queryJob = queryJob.waitFor();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 
-        // Check for errors
         if (queryJob == null) {
             throw new RuntimeException("Job no longer exists");
         } else if (queryJob.getStatus().getError() != null) {
-            // You can also look at queryJob.getStatus().getExecutionErrors() for all
-            // errors, not just the latest one.
             throw new RuntimeException(queryJob.getStatus().getError().toString());
         }
 
-        // Get the results.
         TableResult result;
         try {
             result = queryJob.getQueryResults();
@@ -56,17 +66,6 @@ public class GithubFinder {
             e.printStackTrace();
         }
 
-        // Print all pages of the results.
-
         return null;
-
-        /*System.out.printf("%nid, extension, content (first 50 characters) %n");
-        for (FieldValueList row : result.iterateAll()) {
-            // String type
-            String id = row.get("id").getStringValue();
-            String content = row.get("content").getStringValue();
-            String path1 = row.get("path").getStringValue();
-            System.out.printf("%s, %s, %s %n", id, path1.substring(path1.length()-4, path1.length()), content.replaceAll("\\s+", " ").substring(0, 50));
-        }*/
     }
 }
diff --git a/app/src/main/java/githubsqlfinder/JDBC.java b/app/src/main/java/githubsqlfinder/JDBC.java
index f07facf6ec7552ca9cb13d271ad3435acb5afb22..0011243cbaf86d4e2fdd3cde95b4e278423722f9 100644
--- a/app/src/main/java/githubsqlfinder/JDBC.java
+++ b/app/src/main/java/githubsqlfinder/JDBC.java
@@ -1,6 +1,9 @@
 package githubsqlfinder;
 
 import java.sql.*;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.List;
 
 public class JDBC {
 
@@ -11,8 +14,7 @@ public class JDBC {
         {
             this.connection = DriverManager.getConnection("jdbc:sqlite:sample.db");
             Statement statement = connection.createStatement();
-            statement.setQueryTimeout(30);  // set timeout to 30 sec.
-            //statement.executeUpdate("drop table if exists sql_info");
+            statement.setQueryTimeout(30);
             statement.executeUpdate("create table if not exists sql_info (id integer primary key, sql string, repo_name string, file_path string, db_dialect string)");
         } 
         catch(SQLException e) 
@@ -21,9 +23,23 @@ public class JDBC {
         }
     }
 
+    public void deleteDb() {
+        if (this.connection == null) {
+            this.connect();
+        }
+        try {
+            Statement statement = this.connection.createStatement();
+            statement.executeUpdate("drop table if exists sql_info");
+            statement.executeUpdate("create table if not exists sql_info (id integer primary key, sql string, repo_name string, file_path string, db_dialect string)");
+        } catch (SQLException e) {
+            e.printStackTrace(System.err);
+            System.out.printf("%d ||| %s", e.getErrorCode(), e.getMessage());
+        }
+    }
+
     public void addSqlInfo(String sql, String repoName, String filePath, String dbDialect) {
 
-        if (sql == "<EOF>" || sql == ";") {
+        if (sql.equals("<EOF>")  || sql.equals(";") || sql.equals("<EOF>;")) {
             return;
         }
 
@@ -47,7 +63,7 @@ public class JDBC {
         }
     }
 
-    public void showPage(int offset) {
+    public void showPage(int offset, boolean all) {
 
         if (this.connection == null) {
             this.connect();
@@ -55,7 +71,15 @@ public class JDBC {
 
         try {
             Statement statement = this.connection.createStatement();
-            ResultSet rs = statement.executeQuery("select * from sql_info limit 10 offset " + offset);
+
+            String sql;
+            if (all) {
+                sql = "select * from sql_info";
+            } else {
+                sql = "select * from sql_info limit 100 offset " + offset;
+            }
+ 
+            ResultSet rs = statement.executeQuery(sql);
             System.out.println("Id | Repozitory | File | DB dialect | SQL query");
             while(rs.next())
             {
@@ -66,4 +90,25 @@ public class JDBC {
             System.out.printf("%d ||| %s", e.getErrorCode(), e.getMessage());
         }
     }
+
+    public static void writeCsvFile(String fileName, List<String[]> data) {
+        try (FileWriter writer = new FileWriter(fileName)) {
+            for (String[] row : data) {
+                writeRow(writer, row);
+            }
+            System.out.println("CSV file created: " + fileName);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static void writeRow(FileWriter writer, String[] row) throws IOException {
+        for (int i = 0; i < row.length; i++) {
+            writer.append(row[i]);
+            if (i < row.length - 1) {
+                writer.append(",");
+            }
+        }
+        writer.append("\n");
+    }
 }
\ No newline at end of file
diff --git a/app/src/main/java/githubsqlfinder/notes.md b/app/src/main/java/githubsqlfinder/notes.md
deleted file mode 100644
index 636e25521b107808be5a6ca17fdce4d73f7c401a..0000000000000000000000000000000000000000
--- a/app/src/main/java/githubsqlfinder/notes.md
+++ /dev/null
@@ -1,8 +0,0 @@
-1. ANTLR
-- gramatiky pre 4 najväčšie typy SQL databáz https://www.statista.com/statistics/809750/worldwide-popularity-ranking-database-management-systems/ (oracle (pl/sql), mysql, microsoft sql server (tsql), postgresql): skúsiť skombinovať, ak nie, tak skúšať po jednom dokým sa nenájde
-- pozrieť handlovanie chýb, ak nenájde sql query
-- ako orezať súbor, aby sa prehľadávalo čo najmenšie množstvo dát (začiatočné sql slová - nie je ich veľa)
-- syntax pre rôzne jazyky - spájanie sql príkazov (:p1, @p1, {p1}...)
-- pozretie jednotlivých slovníkov na https://github.com/antlr/grammars-v4/blob/master/sql/tsql/TSqlLexer.g4 
-
-2. Ukladanie do DB
diff --git a/app/src/main/resources/example1.txt b/app/src/main/resources/example1.txt
index 359213a1ef10c56528ba50924a7e5279e65f3168..d390f4b8205e1627d59c04f52b11112770878d50 100644
--- a/app/src/main/resources/example1.txt
+++ b/app/src/main/resources/example1.txt
@@ -1,11 +1,52 @@
-WITH
-  my_av ANALYTIC VIEW AS (
-    USING sales_av HIERARCHIES (time_hier)
-    ADD MEASURES (
-      lag_sales AS (LAG(sales) OVER (HIERARCHY time_hier OFFSET 1))
-    )
-  )
-SELECT time_hier.member_name time, sales, lag_sales
-FROM my_av HIERARCHIES (time_hier)
-WHERE time_hier.level_name = 'YEAR'
-ORDER BY time_hier.hier_order;
\ No newline at end of file
+<?php
+
+class DatabaseOracle {
+	var $mInsertId = null;
+	var $mLastResult = null;
+	var $lastResult = null;
+	var $cursor = 0;
+	var $mAffectedRows;
+
+	var $ignore_DUP_VAL_ON_INDEX = false;
+	var $sequenceData = null;
+
+	var $defaultCharset = 'AL32UTF8';
+
+	var $mFieldInfoCache = array();
+
+	protected function doQuery( $sql ) {
+		wfDebug( "SQL: [$sql]\n" );
+		if ( !mb_check_encoding( $sql ) ) {
+			throw new MWException( "SQL encoding is invalid\n$sql" );
+		}
+
+		// handle some oracle specifics
+		// remove AS column/table/subquery namings
+		if( !$this->getFlag( DBO_DDLMODE ) ) {
+			$sql = preg_replace( '/ as /i', ' ', $sql );
+		}
+
+		// Oracle has issues with UNION clause if the statement includes LOB fields
+		// So we do a UNION ALL and then filter the results array with array_unique
+		$union_unique = ( preg_match( '/\/\* UNION_UNIQUE \*\/ /', $sql ) != 0 );
+		// EXPLAIN syntax in Oracle is EXPLAIN PLAN FOR and it return nothing
+		// you have to select data from plan table after explain
+		$explain_id = date( 'dmYHis' );
+
+		$sql = preg_replace( '/^EXPLAIN /', 'EXPLAIN PLAN SET STATEMENT_ID = \'' . $explain_id . '\' FOR', $sql, 1, $explain_count );
+
+		if ( ( $this->mLastResult = $stmt = oci_parse( $this->mConn, $sql ) ) === false ) {
+			$e = oci_error( $this->mConn );
+			$this->reportQueryError( $e['message'], $e['code'], $sql, __METHOD__ );
+			return false;
+		}
+
+		if ( $explain_count > 0 ) {
+			return $this->doQuery( 'SELECT id, cardinality "ROWS" FROM plan_table WHERE statement_id = \'' . $explain_id . '\'' );
+		} else {
+			$this->mAffectedRows = oci_num_rows( $stmt );
+			return true;
+		}
+	}
+
+} // end DatabaseOracle class
\ No newline at end of file
diff --git a/app/src/main/resources/example10.txt b/app/src/main/resources/example10.txt
index 36c47661af7fc30a837b086e00e414debfa450df..2169f7a570982eb229732f5ccd83e691ee67afc2 100644
--- a/app/src/main/resources/example10.txt
+++ b/app/src/main/resources/example10.txt
@@ -1,12 +1,198 @@
-CREATE TABLE tpcds.customer_demographics (
-    cd_demo_sk integer NOT NULL,
-    cd_gender character(1),
-    cd_marital_status character(1),
-    cd_education_status character varying(20),
-    cd_purchase_estimate integer,
-    cd_credit_rating character varying(10),
-    cd_dep_count integer,
-    cd_dep_employed_count integer,
-    cd_dep_college_count integer
-)
-:DISTRIBUTED_BY;
\ No newline at end of file
+"""
+PostgreSQL users and databases
+==============================
+
+This module provides tools for creating PostgreSQL users and databases.
+
+"""
+from __future__ import with_statement
+
+import re
+
+from fabric.api import cd, env, hide, require, run, settings, sudo
+
+
+def setup_postgis():
+    require('hosts')
+    try:
+        install_postgres()
+    except: pass
+
+    install_postgis()
+    configure_postgis()
+
+def install_postgres():
+    require('hosts')
+    #add repository to be able to install latest version
+    sudo('touch /etc/apt/sources.list.d/pgdg.list')
+    sudo('echo "deb http://apt.postgresql.org/pub/repos/apt/ wheezy-pgdg main" > /etc/apt/sources.list.d/pgdg.list')
+    sudo('wget https://www.postgresql.org/media/keys/ACCC4CF8.asc')
+    sudo('apt-key add ACCC4CF8.asc; aptitude update')
+    sudo('rm ACCC4CF8.asc')
+    #sudo('aptitude install -y postgresql postgresql-server-dev-9.1')
+    sudo('aptitude install -y postgresql postgresql-client postgresql-contrib ')
+
+def install_postgis():
+    require('hosts')
+    #require('basedir')
+
+    #VERSION = '1.5.7'
+    #REP = 'http://download.osgeo.org/postgis/source'
+    #pkg = 'postgis-%s' % VERSION
+    #tar = '%s.tar.gz' % pkg
+
+    _install_postgis_deps()
+
+    #with cd('%(basedir)s/packages' % env):
+    #    if not exists(tar):
+    #        _sudo('wget %s/%s' % (REP, tar))
+    #    if not exists(pkg):
+    #        _sudo('tar xzf %s' % tar)
+    #    with cd(pkg):
+    #        sudo('ldconfig')
+    #        _sudo('./configure && make')
+    #        sudo('make install')
+    sudo('aptitude install -y postgis')
+
+def configure_postgis(password=None):
+    v = postgres_version()
+    if v:
+        #gis_v = postgis_version(v)
+        #contrib = '/usr/share/postgresql/%s/contrib/postgis-%s' % (v[:3], gis_v)
+        for cmd in (
+            '''psql -c "CREATE ROLE gisgroup;"''',
+            '''psql -c "CREATE EXTENSION postgis;"''',
+            '''psql -c "CREATE EXTENSION postgis_topology;"''',
+            #'''createdb -E UTF8 template_postgis''',
+            #'''psql -d template_postgis < %s/postgis.sql''' % contrib,
+            #'''psql -d template_postgis < %s/spatial_ref_sys.sql''' % contrib,
+            #'''psql -c "ALTER TABLE geometry_columns OWNER TO gisgroup;" template_postgis''',
+            #'''psql -c "ALTER TABLE spatial_ref_sys OWNER TO gisgroup;" template_postgis''',
+            ):
+          try:
+            _run(cmd, password)
+          except: pass
+
+def create_user(name, password, groups=None, encrypted=True):
+    """
+    Create a PostgreSQL user.
+
+    Example::
+
+        # Create DB user if it does not exist
+        if not user_exists('dbuser'):
+            create_user('dbuser', password='somerandomstring')
+
+    """
+    if encrypted:
+        with_password = 'WITH ENCRYPTED PASSWORD'
+    else:
+        with_password = 'WITH PASSWORD'
+
+    if groups:
+        groups = ' IN GROUP %s' % ', '.join(groups)
+    else:
+        groups = ''
+
+    _run('''psql -c "CREATE USER %(name)s %(with_password)s '%(password)s'%(groups)s;"''' % locals())
+
+
+def create_database(name, owner, template='template_postgis', encoding='UTF8', locale='en_US.UTF-8'):
+    """
+    Create a PostgreSQL database.
+
+    Example::
+
+        # Create DB if it does not exist
+        if not database_exists('myapp'):
+            create_database('myapp', owner='dbuser')
+
+    """
+    #_run('''createdb --owner %(owner)s --template %(template)s --encoding=%(encoding)s --lc-ctype=%(locale)s --lc-collate=%(locale)s %(name)s''' % locals())
+    #_run('''createdb --owner %(owner)s --encoding=%(encoding)s --lc-ctype=%(locale)s --lc-collate=%(locale)s %(name)s''' % locals())
+    _run('''createdb --owner %(owner)s  %(name)s''' % locals())
+    _run('''psql -d %(name)s -c "CREATE EXTENSION postgis;"''' % locals())
+    _run('''psql -d %(name)s -c "CREATE EXTENSION postgis_topology;"''' % locals())
+
+def user_exists(name):
+    """
+    Check if a PostgreSQL user exists.
+    """
+    with settings(hide('running', 'stdout', 'stderr', 'warnings'), warn_only=True):
+        res = _run('''psql -t -A -c "SELECT COUNT(*) FROM pg_user WHERE usename = '%(name)s';"''' % locals())
+    return (res == "1")
+
+
+def change_password(name, password, encrypted=True):
+    if encrypted:
+        with_password = 'WITH ENCRYPTED PASSWORD'
+    else:
+        with_password = 'WITH PASSWORD'
+    cmd = '''psql -c "ALTER USER %(name)s %(with_password)s '%(password)s';"''' % locals()
+    _run(cmd)
+
+
+def database_exists(name):
+    """
+    Check if a PostgreSQL database exists.
+    """
+    with settings(hide('running', 'stdout', 'stderr', 'warnings'), warn_only=True):
+        return _run('''psql -d %(name)s -c ""''' % locals()).succeeded
+
+def database_backup(name):
+    pass
+
+def database_restore():
+    pass
+
+def unconfigure_postgis(password=None):
+    v = postgres_version()
+    if v:
+        gis_v = postgis_version(v)
+        contrib = '/usr/share/postgresql/%s/contrib/postgis-%s' % (v[:3], gis_v)
+        _run('''psql -d template_postgis < %s/uninstall_postgis.sql''' % contrib, password)
+
+def postgis_version(ver=None):
+    if not ver:
+        ver = postgres_version()
+    else:
+        ver = str(ver)
+    contrib = '/usr/share/postgresql/%s/contrib' % ver[:3]
+    out = qrun('find %s -iname "postgis-*"' % contrib)
+    return out.replace('%s/postgis-' % contrib, '')
+
+def postgres_version():
+    require('hosts')
+    out = qrun('psql --version')
+    s = out.split('\n')[0]
+    m = re.match('.+(\d+)\.(\d+)\.(\d+).*', s)
+    if m:
+        #return '%s.%s.%s' % (m.group(1), m.group(2), m.group(3))
+        return '%s.%s' % (m.group(1), m.group(2))
+    return ''
+
+def warn_only():
+    return settings(hide('running', 'stdout', 'stderr', 'warnings'),
+                    warn_only=True)
+
+def qrun(cmd):
+    with warn_only():
+        return run(cmd)
+
+def _install_postgis_deps():
+    sudo('aptitude install -y libproj-dev libpq-dev')
+
+def _run(command, password=None):
+    """
+    Run command as 'postgres' user
+    """
+    with cd('/var/lib/postgresql'):
+        if password:
+            password = 'PGPASSWORD=%s; ' % password
+        else:
+            password = ''
+        return sudo('%ssudo -u postgres %s' % (password, command))
+
+def _sudo(cmd):
+    require('webapp_user')
+    return sudo(cmd, user='%(webapp_user)s' % env)
\ No newline at end of file
diff --git a/app/src/main/resources/example2.txt b/app/src/main/resources/example2.txt
index ba5f9af0763d8ada0f720d461ad57e516219bd4a..72e0cffa84c029e95482fd5ea97da522575ab8a7 100644
--- a/app/src/main/resources/example2.txt
+++ b/app/src/main/resources/example2.txt
@@ -1,15 +1,52 @@
-autocommit off;
+<?php
 
-create table a ( c char(1));
+class DatabaseOracle {
+	var $mInsertId = null;
+	var $mLastResult = null;
+	var $lastResult = null;
+	var $cursor = 0;
+	var $mAffectedRows;
 
-insert into a values('e');
-select set{'a',c} from a;
-select set{c,cast('a' as varchar)} from a;
-select set{c,cast('e' as varchar)} from a; 
-select set{c,cast('w' as varchar)} from a;
+	var $ignore_DUP_VAL_ON_INDEX = false;
+	var $sequenceData = null;
 
-create table b ( c varchar(1),v char(1));
-insert into b values('e','e');
-select v,c,set{v,c} from b;
+	var $defaultCharset = 'AL32UTF8';
 
-rollback;
\ No newline at end of file
+	var $mFieldInfoCache = array();
+
+	protected function doQuery( $sql ) {
+		wfDebug( "SQL: [$sql]\n" );
+		if ( !mb_check_encoding( $sql ) ) {
+			throw new MWException( "SQL encoding is invalid\n$sql" );
+		}
+
+		// handle some oracle specifics
+		// remove AS column/table/subquery namings
+		if( !$this->getFlag( DBO_DDLMODE ) ) {
+			$sql = preg_replace( '/ as /i', ' ', $sql );
+		}
+
+		// Oracle has issues with UNION clause if the statement includes LOB fields
+		// So we do a UNION ALL and then filter the results array with array_unique
+		$union_unique = ( preg_match( '/\/\* UNION_UNIQUE \*\/ /', $sql ) != 0 );
+		// EXPLAIN syntax in Oracle is EXPLAIN PLAN FOR and it return nothing
+		// you have to select data from plan table after explain
+		$explain_id = date( 'dmYHis' );
+
+		$sql = preg_replace( '/^EXPLAIN /', 'EXPLAIN PLAN SET STATEMENT_ID = \'' . $explain_id . '\' FOR', $sql, 1, $explain_count );
+
+		if ( ( $this->mLastResult = $stmt = oci_parse( $this->mConn, $sql ) ) === false ) {
+			$e = oci_error( $this->mConn );
+			$this->reportQueryError( $e['message'], $e['code'], $sql, __METHOD__ );
+			return false;
+		}
+
+		if ( $explain_count > 0 ) {
+			return $this->doQuery( 'SELECT id, cardinality "ROWS" FROM plan_table WHERE statement_id = \'' . $explain_id . '\' AND statement_id_2 = ' . $explain_id_2 );
+		} else {
+			$this->mAffectedRows = oci_num_rows( $stmt );
+			return true;
+		}
+	}
+
+} // end DatabaseOracle class
\ No newline at end of file
diff --git a/app/src/main/resources/example3.txt b/app/src/main/resources/example3.txt
index 21b929a159ea33b8390896cdedbd932379bcee73..36a2a3555d492804c944f8c810d2b0e47855d372 100644
--- a/app/src/main/resources/example3.txt
+++ b/app/src/main/resources/example3.txt
@@ -1,4 +1,59 @@
--- trace.test
--- 
--- execsql {SELECT 't6int', [t6int], t6int, ?1, "?1", t6int FROM t6}
-SELECT 't6int', [t6int], t6int, ?1, "?1", t6int FROM t6
\ No newline at end of file
+<?php include "../include/config.php"; ?>
+<?php include "../include/header.php"; ?>
+<?php
+
+	if (empty($_GET['StudentID']))
+	{	
+		$result = oci_parse($con, "SELECT * FROM Students ORDER BY Name ASC");
+		oci_execute($result);
+		while($row = oci_fetch_array($result))
+		{
+			$StudentID .= "<option value='" . $row['STUDENTID'] . "'>" . $row['NAME'] . "</option>\n";
+		}
+
+?>
+<p>Hello Student. Please select your name from the list below:<p>
+<form action="index.php" method"get">
+	<table cellpadding="0" cellspacing="0">
+		<tr>
+			<td><b>Name: </b></td>
+			<td><select name="StudentID"><?php echo $StudentID; ?></select></td>
+		</tr>
+	</table>
+	<br />
+	<input type="submit" value="Continue" />
+</form>
+<div class="home">
+	<a href="<?php echo $RootDirectory; ?>index.php">Click here to return home</a>
+</div>
+<?php
+
+	}
+	else
+	{
+		$result = oci_parse($con, "SELECT * FROM Students WHERE StudentID='" . $_GET['StudentID'] . "'");
+		oci_execute($result);
+		$student = oci_fetch_array($result);
+
+?>
+<p>Hello <?php echo $student['NAME']; ?> (Student). You can view any of the following reports:<p>
+<div class="list">
+	<div class="item">
+		<a href="evaluations/report.php?StudentID=<?php echo $student['STUDENTID']; ?>">Calendar of Evaluations</a>
+	</div>
+	<div class="item">
+		<a href="courses/report.php?StudentID=<?php echo $student['STUDENTID']; ?>">My Courses</a>
+	</div>
+	<div class="item">
+		<a href="grades/report.php?StudentID=<?php echo $student['STUDENTID']; ?>">My Grades</a>
+	</div>
+</div>
+<div class="home">
+	<a href="<?php echo $RootDirectory; ?>index.php">Click here to return home</a>
+</div>
+<?php
+
+	}
+
+?>
+<?php include "../include/footer.php"; ?>
\ No newline at end of file
diff --git a/app/src/main/resources/example9.txt b/app/src/main/resources/example9.txt
index 8d6405eea86803378bf067c15441af516afbf3a7..0453c3318cf3b30d3d5c027afc377915460d4f8c 100644
--- a/app/src/main/resources/example9.txt
+++ b/app/src/main/resources/example9.txt
@@ -1,5 +1,246 @@
-CREATE TABLE "agriculture_and_biosciences_exports" (
-	"years"	text,
-	"historical_data"	text,
-	"target"	text
-);
\ No newline at end of file
+(function (factory) {
+    if (typeof module !== 'undefined' && typeof module.exports !== 'undefined' && typeof require !== 'undefined') {
+        // CommonJS
+        factory(module.exports, require('underscore-data'));
+    } else {
+        // running in browser
+        window.warehouse = window.warehouse || {};
+        factory(window.warehouse, _);
+    }
+})(function(exports, _) {
+
+function sqlEscapeIdentifier(value) {
+    // http://dev.mysql.com/doc/refman/5.0/en/identifiers.html
+    // http://www.sqlite.org/lang_keywords.html
+    return '`' + value.replace(/`/g, '``') + '`';
+}
+
+/*
+ * following RQL to SQL conversion taken from:
+ *   http://github.com/persvr/perstore/blob/master/store/sql.js
+ */
+
+var sqlOperators = {
+    "and" : "&",
+    "or" : "|",
+    "eq" : "=",
+    "ne" : "!=",
+    "le" : "<=",
+    "ge" : ">=",
+    "lt" : "<",
+    "gt" : ">"
+};
+
+var valueToSql = function(value){
+    if(value instanceof Array){
+        return "(" + value.map(function(element){
+            return valueToSql(element);
+        }).join(",") + ")";
+    }
+    return typeof(value) == "string" ? "'" + value.replace(/'/g,"''") + "'" : value + '';
+};
+
+var safeSqlName = function(name){
+  if(name.match(/[^\w_*]/)){
+    throw new URIError("Illegal column name " + name);
+  }
+  name = sqlEscapeIdentifier(name);
+  return name;
+};
+
+var generateSql = function(structure){
+  var sql = "SELECT " + (structure.distinct ? 'DISTINCT ' : '') + structure.select + " FROM " + structure.from +
+    (structure.where && (" WHERE " + structure.where)) + (structure.order.length ? (" ORDER BY " + structure.order.join(", ")): "");
+  if (structure.groupBy) {
+    sql += " GROUP BY " + structure.groupBy;
+  }
+  if (structure.limit) {
+    sql += " LIMIT " + structure.limit + " OFFSET " + structure.offset;
+  }
+  return sql;
+};
+
+var generateSqlCount = function(structure){
+  return "SELECT COUNT(*) as count FROM " + structure.from +
+    (structure.where && (" WHERE " + structure.where));
+};
+
+var toSQL = function(options) {
+  options = options || {};
+  var query = this;
+  var limit, count, offset, postHandler, results = true;
+  var where = "";
+  var select = [];
+  var distinct = false;
+  var order = [], groupBy = '';
+  var params = (options.parameters = options.parameters || []);
+
+  function convertRql(query){
+      var conjunction = query.name;
+      query.args.forEach(function(term, index){
+          var column = term.args[0];
+          switch(term.name){
+              case "eq":
+                  if(term.args[1] instanceof Array){
+                      if(term.args[1].length === 0){
+                          // an empty IN clause is considered invalid SQL
+                          if(index > 0){
+                              where += " " + conjunction + " ";
+                          }
+                          where += "0=1";
+                      }
+                      else{
+                          safeSqlName(column);
+                          addClause(column + " IN " + valueToSql(term.args[1]));
+                      }
+                      break;
+                  }
+                  // else fall through
+              case "ne": case "lt": case "le": case "gt": case "ge":
+                  safeSqlName(column);
+                  addClause(options.table + '.' + column + sqlOperators[term.name] + valueToSql(term.args[1]));
+                  break;
+              case "sort":
+                  if(term.args.length === 0)
+                      throw new URIError("Must specify a sort criteria");
+                  term.args.forEach(function(sortAttribute){
+                      var firstChar = sortAttribute.charAt(0);
+                      var orderDir = "ASC";
+                      if(firstChar == "-" || firstChar == "+"){
+                          if(firstChar == "-"){
+                              orderDir = "DESC";
+                          }
+                          sortAttribute = sortAttribute.substring(1);
+                      }
+                      safeSqlName(sortAttribute);
+                      order.push(options.table + "." + sortAttribute + " " + orderDir);
+                  });
+                  break;
+              case "and": case "or":
+                  addClause("(");
+                  convertRql(term);
+                  where += ")";
+                  break;
+              case "in":
+                  //print("in() is deprecated");
+                  if(term.args[1].length === 0){
+                      // an empty IN clause is considered invalid SQL
+                      if(index > 0){
+                          where += " " + conjunction + " ";
+                      }
+                      where += "0=1";
+                  }
+                  else{
+                      safeSqlName(column);
+                      addClause(column + " IN " + valueToSql(term.args[1]));
+                  }
+                  break;
+              case "out":
+                  //print("in() is deprecated");
+                  if(term.args[1].length === 0){
+                      // an empty IN clause is considered invalid SQL
+                      if(index > 0){
+                          where += " " + conjunction + " ";
+                      }
+                      where += "0=1";
+                  }
+                  else{
+                      safeSqlName(column);
+                      addClause(column + " NOT IN " + valueToSql(term.args[1]));
+                  }
+                  break;
+              case "select":
+                  term.args.forEach(safeSqlName);
+                  select = select.concat(term.args);
+                  break;
+              case "distinct":
+                  distinct = true;
+                  break;
+              case "count":
+                  count = true;
+                  results = false;
+                  postHandler = function(){
+                      return count;
+                  };
+                  break;
+              case "one": case "first":
+                  limit = term.name == "one" ? 2 : 1;
+                  postHandler = function(){
+                      var firstRow;
+                      return when(results.rows.some(function(row){
+                          if(firstRow){
+                              throw new TypeError("More than one object found");
+                          }
+                          firstRow = row;
+                      }), function(){
+                          return firstRow;
+                      });
+                  };
+                  break;
+              case "limit":
+                  limit = term.args[0];
+                  offset = term.args[1];
+                  count = term.args[2] > limit;
+                  break;
+              case "aggregate":
+                  groupBy = column;
+                  safeSqlName(groupBy);
+                  column = term.args[1].args[0];
+                  term.name = term.args[1].name;
+                  // break is intentionally missing
+              case "mean":
+                  term.name = "avg";
+              case "sum": case "max": case "min":
+                  select.push(term.name + "(" + safeSqlName(column) + ") as value");
+                  postHandler = function(){
+                      var firstRow;
+                      return when(results.rows.some(function(row){
+                          firstRow = row;
+                      }), function(){
+                          return firstRow.value;
+                      });
+                  };
+                  break;
+              case "search":
+                  safeSqlName(column);
+                  addClause("MATCH (" + column + ") AGAINST (" + valueToSql(term.args[1]) + " IN BOOLEAN MODE)");
+                  break;
+              default:
+                  throw new URIError("Invalid query syntax, " + term.name+ " not implemented");
+          }
+          function addClause(sqlClause){
+              if(where && !where.match(/\(\s*$/)){
+                  where += " " + conjunction + " ";
+              }
+              where += sqlClause;
+          }
+      });
+  }
+  convertRql(query);
+  var structure = {
+      select: select.length > 0 ? select.join(',') : '*',
+      distinct: distinct,
+      from: options.table,
+      where: where,
+      groupBy: groupBy,
+      order: order,
+      limit: limit,
+      offset: offset || 0
+  };
+  var sql;
+  if(count){
+      sql = generateSqlCount(structure);
+  } else {
+    sql = generateSql(structure);
+  }
+  return sql;
+};
+
+var rql2sql = function(query, options) {
+    return toSQL.call(query, options);
+};
+
+exports.rql2sql = rql2sql;
+exports.sqlEscapeIdentifier = sqlEscapeIdentifier;
+
+});
\ No newline at end of file
diff --git a/sample.db b/sample.db
index 8bf7527ccff117d47135e223008cea683a22b8ea..a6f53dc6cc8375a9c2b2156befe6015a554d1be1 100644
Binary files a/sample.db and b/sample.db differ