diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/CheckstyleParserErrorStrategy.java b/src/main/java/com/puppycrawl/tools/checkstyle/CheckstyleParserErrorStrategy.java
new file mode 100644
--- /dev/null
+++ b/src/main/java/com/puppycrawl/tools/checkstyle/CheckstyleParserErrorStrategy.java
@@ -0,0 +1,41 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2021 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.puppycrawl.tools.checkstyle;
+
+import org.antlr.v4.runtime.BailErrorStrategy;
+import org.antlr.v4.runtime.InputMismatchException;
+import org.antlr.v4.runtime.Parser;
+import org.antlr.v4.runtime.Token;
+
+/**
+ * Extending BailErrorStrategy allows us to report errors while
+ * cancelling the parsing operation. If input is not syntactically
+ * correct, we do not need to use antlr's recovery strategy, which
+ * can add significant overhead.
+ *
+ */
+public class CheckstyleParserErrorStrategy extends BailErrorStrategy {
+
+    @Override
+    public Token recoverInline(Parser recognizer) {
+        reportError(recognizer, new InputMismatchException(recognizer));
+        return super.recoverInline(recognizer);
+    }
+}
diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/DetailAstImpl.java b/src/main/java/com/puppycrawl/tools/checkstyle/DetailAstImpl.java
--- a/src/main/java/com/puppycrawl/tools/checkstyle/DetailAstImpl.java
+++ b/src/main/java/com/puppycrawl/tools/checkstyle/DetailAstImpl.java
@@ -20,22 +20,21 @@
 package com.puppycrawl.tools.checkstyle;
 
 import java.util.BitSet;
+import java.util.Collections;
+import java.util.List;
+
+import org.antlr.v4.runtime.Token;
 
-import antlr.CommonASTWithHiddenTokens;
-import antlr.Token;
-import antlr.collections.AST;
 import com.puppycrawl.tools.checkstyle.api.DetailAST;
 import com.puppycrawl.tools.checkstyle.utils.TokenUtil;
 
 /**
  * The implementation of {@link DetailAST}. This should only be directly used to
- * create custom AST nodes.
+ * create custom AST nodes and in 'JavaAstVisitor.java'.
  *
- * @noinspection FieldNotUsedInToString, SerializableHasSerializationMethods
+ * @noinspection FieldNotUsedInToString
  */
-public final class DetailAstImpl extends CommonASTWithHiddenTokens implements DetailAST {
-
-    private static final long serialVersionUID = -2580884815577559874L;
+public final class DetailAstImpl implements DetailAST {
 
     /** Constant to indicate if not calculated the child count. */
     private static final int NOT_INITIALIZED = Integer.MIN_VALUE;
@@ -52,6 +51,30 @@ public final class DetailAstImpl extends CommonASTWithHiddenTokens implements De
     /** Previous sibling. */
     private DetailAstImpl previousSibling;
 
+    /** First child of this DetailAST. */
+    private DetailAstImpl firstChild;
+
+    /** First sibling of this DetailAST.*/
+    private DetailAstImpl nextSibling;
+
+    /** Text of this DetailAST. */
+    private String text;
+
+    /** The type of this DetailAST. */
+    private int type;
+
+    /**
+     * All tokens on COMMENTS channel to the left of the current token up to the
+     * preceding token on the DEFAULT_TOKEN_CHANNEL.
+     */
+    private List<Token> hiddenBefore;
+
+    /**
+     * All tokens on COMMENTS channel to the right of the current token up to the
+     * next token on the DEFAULT_TOKEN_CHANNEL.
+     */
+    private List<Token> hiddenAfter;
+
     /**
      * All token types in this branch.
      * Token 'x' (where x is an int) is in this branch
@@ -59,47 +82,27 @@ public final class DetailAstImpl extends CommonASTWithHiddenTokens implements De
      */
     private BitSet branchTokenTypes;
 
-    @Override
-    public void initialize(Token token) {
-        super.initialize(token);
-        lineNo = token.getLine();
-
-        // expect columns to start @ 0
-        columnNo = token.getColumn() - 1;
-    }
-
-    @Override
-    public void initialize(AST ast) {
-        final DetailAstImpl detailAst = (DetailAstImpl) ast;
-        setText(detailAst.getText());
-        setType(detailAst.getType());
-        lineNo = detailAst.getLineNo();
-        columnNo = detailAst.getColumnNo();
-        hiddenAfter = detailAst.getHiddenAfter();
-        hiddenBefore = detailAst.getHiddenBefore();
-    }
-
-    @Override
-    public void setFirstChild(AST ast) {
-        clearBranchTokenTypes();
-        clearChildCountCache(this);
-        super.setFirstChild(ast);
-        if (ast != null) {
-            ((DetailAstImpl) ast).setParent(this);
-        }
+    /**
+     * Initializes this DetailAstImpl.
+     *
+     * @param tokenType the type of this DetailAstImpl
+     * @param tokenText the text of this DetailAstImpl
+     */
+    public void initialize(int tokenType, String tokenText) {
+        type = tokenType;
+        text = tokenText;
     }
 
-    @Override
-    public void setNextSibling(AST ast) {
-        clearBranchTokenTypes();
-        clearChildCountCache(parent);
-        super.setNextSibling(ast);
-        if (ast != null && parent != null) {
-            ((DetailAstImpl) ast).setParent(parent);
-        }
-        if (ast != null) {
-            ((DetailAstImpl) ast).previousSibling = this;
-        }
+    /**
+     * Initializes this DetailAstImpl.
+     *
+     * @param token the token to generate this DetailAstImpl from
+     */
+    public void initialize(Token token) {
+        text = token.getText();
+        type = token.getType();
+        lineNo = token.getLine();
+        columnNo = token.getCharPositionInLine();
     }
 
     /**
@@ -130,22 +133,21 @@ else if (parent != null) {
     }
 
     /**
-     * Add next sibling.
+     * Add next sibling, pushes other siblings back.
      *
-     * @param ast
-     *        DetailAST object.
+     * @param ast DetailAST object.
      */
     public void addNextSibling(DetailAST ast) {
         clearBranchTokenTypes();
         clearChildCountCache(parent);
         if (ast != null) {
             // parent is set in setNextSibling
-            final DetailAstImpl nextSibling = getNextSibling();
+            final DetailAstImpl sibling = nextSibling;
             final DetailAstImpl astImpl = (DetailAstImpl) ast;
 
-            if (nextSibling != null) {
-                astImpl.setNextSibling(nextSibling);
-                nextSibling.previousSibling = astImpl;
+            if (sibling != null) {
+                astImpl.setNextSibling(sibling);
+                sibling.previousSibling = astImpl;
             }
 
             astImpl.previousSibling = this;
@@ -153,16 +155,30 @@ public void addNextSibling(DetailAST ast) {
         }
     }
 
-    @Override
-    public void addChild(AST ast) {
+    /**
+     * Adds a new child to the current AST.
+     *
+     * @param child to DetailAST to add as child
+     */
+    public void addChild(DetailAST child) {
         clearBranchTokenTypes();
         clearChildCountCache(this);
-        if (ast != null) {
-            final DetailAstImpl astImpl = (DetailAstImpl) ast;
+        if (child != null) {
+            final DetailAstImpl astImpl = (DetailAstImpl) child;
             astImpl.setParent(this);
             astImpl.previousSibling = (DetailAstImpl) getLastChild();
         }
-        super.addChild(ast);
+        DetailAST temp = firstChild;
+        if (temp == null) {
+            firstChild = (DetailAstImpl) child;
+        }
+        else {
+            while (temp.getNextSibling() != null) {
+                temp = temp.getNextSibling();
+            }
+
+            ((DetailAstImpl) temp).setNextSibling(child);
+        }
     }
 
     @Override
@@ -170,7 +186,7 @@ public int getChildCount() {
         // lazy init
         if (childCount == NOT_INITIALIZED) {
             childCount = 0;
-            AST child = getFirstChild();
+            DetailAST child = firstChild;
 
             while (child != null) {
                 childCount += 1;
@@ -181,10 +197,10 @@ public int getChildCount() {
     }
 
     @Override
-    public int getChildCount(int type) {
+    public int getChildCount(int tokenType) {
         int count = 0;
-        for (AST ast = getFirstChild(); ast != null; ast = ast.getNextSibling()) {
-            if (ast.getType() == type) {
+        for (DetailAST ast = firstChild; ast != null; ast = ast.getNextSibling()) {
+            if (ast.getType() == tokenType) {
                 count++;
             }
         }
@@ -201,7 +217,7 @@ private void setParent(DetailAstImpl parent) {
         do {
             instance.clearBranchTokenTypes();
             instance.parent = parent;
-            instance = instance.getNextSibling();
+            instance = instance.nextSibling;
         } while (instance != null);
     }
 
@@ -210,6 +226,34 @@ public DetailAST getParent() {
         return parent;
     }
 
+    @Override
+    public String getText() {
+        return text;
+    }
+
+    /**
+     * Sets the text for this DetailAstImpl.
+     *
+     * @param text the text field of this DetailAstImpl
+     */
+    public void setText(String text) {
+        this.text = text;
+    }
+
+    @Override
+    public int getType() {
+        return type;
+    }
+
+    /**
+     * Sets the type of this AST.
+     *
+     * @param type the token type of this DetailAstImpl
+     */
+    public void setType(int type) {
+        this.type = type;
+    }
+
     @Override
     public int getLineNo() {
         int resultNo = -1;
@@ -217,10 +261,10 @@ public int getLineNo() {
         if (lineNo == NOT_INITIALIZED) {
             // an inner AST that has been initialized
             // with initialize(String text)
-            resultNo = findLineNo(getFirstChild());
+            resultNo = findLineNo(firstChild);
 
             if (resultNo == -1) {
-                resultNo = findLineNo(getNextSibling());
+                resultNo = findLineNo(nextSibling);
             }
         }
         if (resultNo == -1) {
@@ -246,10 +290,10 @@ public int getColumnNo() {
         if (columnNo == NOT_INITIALIZED) {
             // an inner AST that has been initialized
             // with initialize(String text)
-            resultNo = findColumnNo(getFirstChild());
+            resultNo = findColumnNo(firstChild);
 
             if (resultNo == -1) {
-                resultNo = findColumnNo(getNextSibling());
+                resultNo = findColumnNo(nextSibling);
             }
         }
         if (resultNo == -1) {
@@ -270,9 +314,9 @@ public void setColumnNo(int columnNo) {
 
     @Override
     public DetailAST getLastChild() {
-        DetailAST ast = getFirstChild();
-        while (ast != null && ast.getNextSibling() != null) {
-            ast = ast.getNextSibling();
+        DetailAstImpl ast = firstChild;
+        while (ast != null && ast.nextSibling != null) {
+            ast = ast.nextSibling;
         }
         return ast;
     }
@@ -330,23 +374,23 @@ private BitSet getBranchTokenTypes() {
         // lazy init
         if (branchTokenTypes == null) {
             branchTokenTypes = new BitSet();
-            branchTokenTypes.set(getType());
+            branchTokenTypes.set(type);
 
             // add union of all children
-            DetailAstImpl child = getFirstChild();
+            DetailAstImpl child = firstChild;
             while (child != null) {
                 final BitSet childTypes = child.getBranchTokenTypes();
                 branchTokenTypes.or(childTypes);
 
-                child = child.getNextSibling();
+                child = child.nextSibling;
             }
         }
         return branchTokenTypes;
     }
 
     @Override
-    public boolean branchContains(int type) {
-        return getBranchTokenTypes().get(type);
+    public boolean branchContains(int tokenType) {
+        return getBranchTokenTypes().get(tokenType);
     }
 
     @Override
@@ -355,10 +399,10 @@ public DetailAST getPreviousSibling() {
     }
 
     @Override
-    public DetailAST findFirstToken(int type) {
+    public DetailAST findFirstToken(int tokenType) {
         DetailAST returnValue = null;
-        for (DetailAST ast = getFirstChild(); ast != null; ast = ast.getNextSibling()) {
-            if (ast.getType() == type) {
+        for (DetailAST ast = firstChild; ast != null; ast = ast.getNextSibling()) {
+            if (ast.getType() == tokenType) {
                 returnValue = ast;
                 break;
             }
@@ -368,22 +412,27 @@ public DetailAST findFirstToken(int type) {
 
     @Override
     public String toString() {
-        return super.toString() + "[" + getLineNo() + "x" + getColumnNo() + "]";
+        return text + "[" + getLineNo() + "x" + getColumnNo() + "]";
     }
 
     @Override
     public DetailAstImpl getNextSibling() {
-        return (DetailAstImpl) super.getNextSibling();
+        return nextSibling;
     }
 
     @Override
     public DetailAstImpl getFirstChild() {
-        return (DetailAstImpl) super.getFirstChild();
+        return firstChild;
+    }
+
+    @Override
+    public int getNumberOfChildren() {
+        return getChildCount();
     }
 
     @Override
     public boolean hasChildren() {
-        return getFirstChild() != null;
+        return firstChild != null;
     }
 
     /**
@@ -409,4 +458,87 @@ private void clearBranchTokenTypes() {
         }
     }
 
+    /**
+     * Sets the next sibling of this AST.
+     *
+     * @param nextSibling the DetailAST to set as sibling
+     */
+    public void setNextSibling(DetailAST nextSibling) {
+        clearBranchTokenTypes();
+        clearChildCountCache(parent);
+        this.nextSibling = (DetailAstImpl) nextSibling;
+        if (nextSibling != null && parent != null) {
+            ((DetailAstImpl) nextSibling).setParent(parent);
+        }
+        if (nextSibling != null) {
+            ((DetailAstImpl) nextSibling).previousSibling = this;
+        }
+    }
+
+    /**
+     * Sets the first child of this AST.
+     *
+     * @param firstChild the DetailAST to set as first child
+     */
+    public void setFirstChild(DetailAST firstChild) {
+        clearBranchTokenTypes();
+        clearChildCountCache(this);
+        this.firstChild = (DetailAstImpl) firstChild;
+        if (firstChild != null) {
+            ((DetailAstImpl) firstChild).setParent(this);
+        }
+    }
+
+    /**
+     * Removes all children of this AST.
+     */
+    public void removeChildren() {
+        firstChild = null;
+    }
+
+    /**
+     * Get list of tokens on COMMENTS channel to the left of the
+     * current token up to the preceding token on the DEFAULT_TOKEN_CHANNEL.
+     *
+     * @return list of comment tokens
+     */
+    public List<Token> getHiddenBefore() {
+        List<Token> returnList = null;
+        if (hiddenBefore != null) {
+            returnList = Collections.unmodifiableList(hiddenBefore);
+        }
+        return returnList;
+    }
+
+    /**
+     * Get list tokens on COMMENTS channel to the right of the current
+     * token up to the next token on the DEFAULT_TOKEN_CHANNEL.
+     *
+     * @return list of comment tokens
+     */
+    public List<Token> getHiddenAfter() {
+        List<Token> returnList = null;
+        if (hiddenAfter != null) {
+            returnList = Collections.unmodifiableList(hiddenAfter);
+        }
+        return returnList;
+    }
+
+    /**
+     * Sets the hiddenBefore token field.
+     *
+     * @param hiddenBefore comment token preceding this DetailAstImpl
+     */
+    public void setHiddenBefore(List<Token> hiddenBefore) {
+        this.hiddenBefore = Collections.unmodifiableList(hiddenBefore);
+    }
+
+    /**
+     * Sets the hiddenAfter token field.
+     *
+     * @param hiddenAfter comment token following this DetailAstImpl
+     */
+    public void setHiddenAfter(List<Token> hiddenAfter) {
+        this.hiddenAfter = Collections.unmodifiableList(hiddenAfter);
+    }
 }
diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/JavaAstVisitor.java b/src/main/java/com/puppycrawl/tools/checkstyle/JavaAstVisitor.java
new file mode 100644
--- /dev/null
+++ b/src/main/java/com/puppycrawl/tools/checkstyle/JavaAstVisitor.java
@@ -0,0 +1,2163 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2021 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.puppycrawl.tools.checkstyle;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Optional;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.stream.Collectors;
+
+import org.antlr.v4.runtime.BufferedTokenStream;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+import com.puppycrawl.tools.checkstyle.api.TokenTypes;
+import com.puppycrawl.tools.checkstyle.grammar.java.CheckstyleJavaParser;
+import com.puppycrawl.tools.checkstyle.grammar.java.CheckstyleJavaParserBaseVisitor;
+import com.puppycrawl.tools.checkstyle.grammar.java.JavaLexer;
+import com.puppycrawl.tools.checkstyle.utils.TokenUtil;
+
+/**
+ * Visitor class used to build Checkstyle's Java AST from the parse tree produced by
+ * {@link CheckstyleJavaParser}. In each {@code visit...} method, we visit the children of a node
+ * (which correspond to subrules) or create terminal nodes (tokens), and return a subtree as a
+ * result.
+ *
+ * <p>Example:</p>
+ *
+ * <p>The following package declaration:</p>
+ * <pre>
+ * package com.puppycrawl.tools.checkstyle;
+ * </pre>
+ *
+ * <p>
+ * Will be parsed by the {@code packageDeclaration} rule from {@code CheckstyleJavaParser.g4}:
+ * </p>
+ * <pre>
+ * packageDeclaration
+ *     : annotations[true] LITERAL_PACKAGE qualifiedName SEMI
+ *     ;
+ * </pre>
+ *
+ * <p>
+ * We override the {@code visitPackageDeclaration} method generated by ANTLR in
+ * {@code CheckstyleJavaParserBaseVisitor} at
+ * {@link JavaAstVisitor#visitPackageDeclaration(CheckstyleJavaParser.PackageDeclarationContext)}
+ * to create a subtree based on the subrules and tokens found in the {@code packageDeclaration}
+ * subrule accordingly, thus producing the following AST:
+ * </p>
+ * <pre>
+ * PACKAGE_DEF -&gt; package
+ * |--ANNOTATIONS -&gt; ANNOTATIONS
+ * |--DOT -&gt; .
+ * |   |--DOT -&gt; .
+ * |   |   |--DOT -&gt; .
+ * |   |   |   |--IDENT -&gt; com
+ * |   |   |   `--IDENT -&gt; puppycrawl
+ * |   |   `--IDENT -&gt; tools
+ * |   `--IDENT -&gt; checkstyle
+ * `--SEMI -&gt; ;
+ * </pre>
+ * <p>
+ * See https://github.com/checkstyle/checkstyle/pull/10434 for a good example of how
+ * to make changes to Checkstyle's grammar and AST.
+ * </p>
+ * <p>
+ * The order of {@code visit...} methods in {@code JavaAstVisitor.java} and production rules in
+ * {@code CheckstyleJavaParser.g4} should be consistent to ease maintenance.
+ * </p>
+ */
+public final class JavaAstVisitor extends CheckstyleJavaParserBaseVisitor<DetailAstImpl> {
+
+    /** String representation of the left shift operator. */
+    private static final String LEFT_SHIFT = "<<";
+
+    /** String representation of the unsigned right shift operator. */
+    private static final String UNSIGNED_RIGHT_SHIFT = ">>>";
+
+    /** String representation of the right shift operator. */
+    private static final String RIGHT_SHIFT = ">>";
+
+    /** Token stream to check for hidden tokens. */
+    private final BufferedTokenStream tokens;
+
+    /**
+     * Constructs a JavaAstVisitor with given token stream.
+     *
+     * @param tokenStream the token stream to check for hidden tokens
+     */
+    public JavaAstVisitor(CommonTokenStream tokenStream) {
+        tokens = tokenStream;
+    }
+
+    @Override
+    public DetailAstImpl visitCompilationUnit(CheckstyleJavaParser.CompilationUnitContext ctx) {
+        final DetailAstImpl root = visit(ctx.children.get(0));
+        for (int i = 1; i < ctx.children.size(); i++) {
+            addLastSibling(root, visit(ctx.children.get(i)));
+        }
+        return root;
+    }
+
+    @Override
+    public DetailAstImpl visitPackageDeclaration(
+            CheckstyleJavaParser.PackageDeclarationContext ctx) {
+        final DetailAstImpl packageDeclaration =
+                create(TokenTypes.PACKAGE_DEF, (Token) ctx.LITERAL_PACKAGE().getPayload());
+        packageDeclaration.addChild(visit(ctx.annotations()));
+        packageDeclaration.addChild(visit(ctx.qualifiedName()));
+        packageDeclaration.addChild(create(ctx.SEMI()));
+        return packageDeclaration;
+    }
+
+    @Override
+    public DetailAstImpl visitImportDec(CheckstyleJavaParser.ImportDecContext ctx) {
+        final DetailAstImpl importRoot = create(ctx.start);
+
+        // Static import
+        if (ctx.LITERAL_STATIC() != null) {
+            importRoot.setType(TokenTypes.STATIC_IMPORT);
+            importRoot.addChild(create(ctx.LITERAL_STATIC()));
+        }
+
+        // Handle star imports
+        final boolean isStarImport = ctx.STAR() != null;
+        if (isStarImport) {
+            final DetailAstImpl dot = create(ctx.DOT());
+            dot.addChild(visit(ctx.qualifiedName()));
+            dot.addChild(create(ctx.STAR()));
+            importRoot.addChild(dot);
+        }
+        else {
+            importRoot.addChild(visit(ctx.qualifiedName()));
+        }
+
+        importRoot.addChild(create(ctx.SEMI()));
+        return importRoot;
+    }
+
+    @Override
+    public DetailAstImpl visitSingleSemiImport(CheckstyleJavaParser.SingleSemiImportContext ctx) {
+        return create(ctx.SEMI());
+    }
+
+    @Override
+    public DetailAstImpl visitTypeDeclaration(CheckstyleJavaParser.TypeDeclarationContext ctx) {
+        final DetailAstImpl typeDeclaration;
+        if (ctx.type == null) {
+            typeDeclaration = create(ctx.semi.get(0));
+            ctx.semi.subList(1, ctx.semi.size())
+                    .forEach(semi -> addLastSibling(typeDeclaration, create(semi)));
+        }
+        else {
+            typeDeclaration = visit(ctx.type);
+        }
+        return typeDeclaration;
+    }
+
+    @Override
+    public DetailAstImpl visitModifier(CheckstyleJavaParser.ModifierContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitVariableModifier(CheckstyleJavaParser.VariableModifierContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitClassDeclaration(CheckstyleJavaParser.ClassDeclarationContext ctx) {
+        return createTypeDeclaration(ctx, TokenTypes.CLASS_DEF, ctx.mods);
+    }
+
+    @Override
+    public DetailAstImpl visitRecordDeclaration(CheckstyleJavaParser.RecordDeclarationContext ctx) {
+        return createTypeDeclaration(ctx, TokenTypes.RECORD_DEF, ctx.mods);
+    }
+
+    @Override
+    public DetailAstImpl visitRecordComponentsList(
+            CheckstyleJavaParser.RecordComponentsListContext ctx) {
+        final DetailAstImpl lparen = create(ctx.LPAREN());
+
+        // We make a "RECORD_COMPONENTS" node whether components exist or not
+        if (ctx.recordComponents() == null) {
+            addLastSibling(lparen, createImaginary(TokenTypes.RECORD_COMPONENTS));
+        }
+        else {
+            addLastSibling(lparen, visit(ctx.recordComponents()));
+        }
+        addLastSibling(lparen, create(ctx.RPAREN()));
+        return lparen;
+    }
+
+    @Override
+    public DetailAstImpl visitRecordComponents(CheckstyleJavaParser.RecordComponentsContext ctx) {
+        final DetailAstImpl recordComponents = createImaginary(TokenTypes.RECORD_COMPONENTS);
+        processChildren(recordComponents, ctx.children);
+        return recordComponents;
+    }
+
+    @Override
+    public DetailAstImpl visitRecordComponent(CheckstyleJavaParser.RecordComponentContext ctx) {
+        final DetailAstImpl recordComponent = createImaginary(TokenTypes.RECORD_COMPONENT_DEF);
+        processChildren(recordComponent, ctx.children);
+        return recordComponent;
+    }
+
+    @Override
+    public DetailAstImpl visitLastRecordComponent(
+            CheckstyleJavaParser.LastRecordComponentContext ctx) {
+        final DetailAstImpl recordComponent = createImaginary(TokenTypes.RECORD_COMPONENT_DEF);
+        processChildren(recordComponent, ctx.children);
+        return recordComponent;
+    }
+
+    @Override
+    public DetailAstImpl visitRecordBody(CheckstyleJavaParser.RecordBodyContext ctx) {
+        final DetailAstImpl objBlock = createImaginary(TokenTypes.OBJBLOCK);
+        processChildren(objBlock, ctx.children);
+        return objBlock;
+    }
+
+    @Override
+    public DetailAstImpl visitCompactConstructorDeclaration(
+            CheckstyleJavaParser.CompactConstructorDeclarationContext ctx) {
+        final DetailAstImpl compactConstructor = createImaginary(TokenTypes.COMPACT_CTOR_DEF);
+        compactConstructor.addChild(createModifiers(ctx.mods));
+        compactConstructor.addChild(visit(ctx.id()));
+        compactConstructor.addChild(visit(ctx.constructorBlock()));
+        return compactConstructor;
+    }
+
+    @Override
+    public DetailAstImpl visitClassExtends(CheckstyleJavaParser.ClassExtendsContext ctx) {
+        final DetailAstImpl classExtends = create(ctx.EXTENDS_CLAUSE());
+        classExtends.addChild(visit(ctx.type));
+        return classExtends;
+    }
+
+    @Override
+    public DetailAstImpl visitImplementsClause(CheckstyleJavaParser.ImplementsClauseContext ctx) {
+        final DetailAstImpl classImplements = create(TokenTypes.IMPLEMENTS_CLAUSE,
+                (Token) ctx.LITERAL_IMPLEMENTS().getPayload());
+        classImplements.addChild(visit(ctx.typeList()));
+        return classImplements;
+    }
+
+    @Override
+    public DetailAstImpl visitTypeParameters(CheckstyleJavaParser.TypeParametersContext ctx) {
+        final DetailAstImpl typeParameters = createImaginary(TokenTypes.TYPE_PARAMETERS);
+        typeParameters.addChild(create(TokenTypes.GENERIC_START, (Token) ctx.LT().getPayload()));
+        // Exclude '<' and '>'
+        processChildren(typeParameters, ctx.children.subList(1, ctx.children.size() - 1));
+        typeParameters.addChild(create(TokenTypes.GENERIC_END, (Token) ctx.GT().getPayload()));
+        return typeParameters;
+    }
+
+    @Override
+    public DetailAstImpl visitTypeParameter(CheckstyleJavaParser.TypeParameterContext ctx) {
+        final DetailAstImpl typeParameter = createImaginary(TokenTypes.TYPE_PARAMETER);
+        processChildren(typeParameter, ctx.children);
+        return typeParameter;
+    }
+
+    @Override
+    public DetailAstImpl visitTypeUpperBounds(CheckstyleJavaParser.TypeUpperBoundsContext ctx) {
+        // In this case, we call 'extends` TYPE_UPPER_BOUNDS
+        final DetailAstImpl typeUpperBounds = create(TokenTypes.TYPE_UPPER_BOUNDS,
+                (Token) ctx.EXTENDS_CLAUSE().getPayload());
+        // 'extends' is child[0]
+        processChildren(typeUpperBounds, ctx.children.subList(1, ctx.children.size()));
+        return typeUpperBounds;
+    }
+
+    @Override
+    public DetailAstImpl visitTypeBound(CheckstyleJavaParser.TypeBoundContext ctx) {
+        final DetailAstImpl typeBoundType = visit(ctx.typeBoundType(0));
+        final Iterator<CheckstyleJavaParser.TypeBoundTypeContext> typeBoundTypeIterator =
+                ctx.typeBoundType().listIterator(1);
+        ctx.BAND().forEach(band -> {
+            addLastSibling(typeBoundType, create(TokenTypes.TYPE_EXTENSION_AND,
+                                (Token) band.getPayload()));
+            addLastSibling(typeBoundType, visit(typeBoundTypeIterator.next()));
+        });
+        return typeBoundType;
+    }
+
+    @Override
+    public DetailAstImpl visitTypeBoundType(CheckstyleJavaParser.TypeBoundTypeContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitEnumDeclaration(CheckstyleJavaParser.EnumDeclarationContext ctx) {
+        return createTypeDeclaration(ctx, TokenTypes.ENUM_DEF, ctx.mods);
+    }
+
+    @Override
+    public DetailAstImpl visitEnumBody(CheckstyleJavaParser.EnumBodyContext ctx) {
+        final DetailAstImpl objBlock = createImaginary(TokenTypes.OBJBLOCK);
+        processChildren(objBlock, ctx.children);
+        return objBlock;
+    }
+
+    @Override
+    public DetailAstImpl visitEnumConstants(CheckstyleJavaParser.EnumConstantsContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitEnumConstant(CheckstyleJavaParser.EnumConstantContext ctx) {
+        final DetailAstImpl enumConstant =
+                createImaginary(TokenTypes.ENUM_CONSTANT_DEF);
+        processChildren(enumConstant, ctx.children);
+        return enumConstant;
+    }
+
+    @Override
+    public DetailAstImpl visitEnumBodyDeclarations(
+            CheckstyleJavaParser.EnumBodyDeclarationsContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitInterfaceDeclaration(
+            CheckstyleJavaParser.InterfaceDeclarationContext ctx) {
+        return createTypeDeclaration(ctx, TokenTypes.INTERFACE_DEF, ctx.mods);
+    }
+
+    @Override
+    public DetailAstImpl visitInterfaceExtends(CheckstyleJavaParser.InterfaceExtendsContext ctx) {
+        final DetailAstImpl interfaceExtends = create(ctx.EXTENDS_CLAUSE());
+        interfaceExtends.addChild(visit(ctx.typeList()));
+        return interfaceExtends;
+    }
+
+    @Override
+    public DetailAstImpl visitClassBody(CheckstyleJavaParser.ClassBodyContext ctx) {
+        final DetailAstImpl objBlock = createImaginary(TokenTypes.OBJBLOCK);
+        processChildren(objBlock, ctx.children);
+        return objBlock;
+    }
+
+    @Override
+    public DetailAstImpl visitInterfaceBody(CheckstyleJavaParser.InterfaceBodyContext ctx) {
+        final DetailAstImpl objBlock = createImaginary(TokenTypes.OBJBLOCK);
+        processChildren(objBlock, ctx.children);
+        return objBlock;
+    }
+
+    @Override
+    public DetailAstImpl visitEmptyClass(CheckstyleJavaParser.EmptyClassContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitClassBlock(CheckstyleJavaParser.ClassBlockContext ctx) {
+        final DetailAstImpl classBlock;
+        if (ctx.LITERAL_STATIC() == null) {
+            // We call it an INSTANCE_INIT
+            classBlock = createImaginary(TokenTypes.INSTANCE_INIT);
+        }
+        else {
+            classBlock = create(TokenTypes.STATIC_INIT, (Token) ctx.LITERAL_STATIC().getPayload());
+            classBlock.setText(TokenUtil.getTokenName(TokenTypes.STATIC_INIT));
+        }
+        classBlock.addChild(visit(ctx.block()));
+        return classBlock;
+    }
+
+    @Override
+    public DetailAstImpl visitMethodDeclaration(CheckstyleJavaParser.MethodDeclarationContext ctx) {
+        final DetailAstImpl methodDef = createImaginary(TokenTypes.METHOD_DEF);
+        methodDef.addChild(createModifiers(ctx.mods));
+
+        // Process all children except C style array declarators
+        processChildren(methodDef, ctx.children.stream()
+                .filter(child -> !(child instanceof CheckstyleJavaParser.ArrayDeclaratorContext))
+                .collect(Collectors.toList()));
+
+        // We add C style array declarator brackets to TYPE ast
+        final DetailAstImpl typeAst = (DetailAstImpl) methodDef.findFirstToken(TokenTypes.TYPE);
+        ctx.cStyleArrDec.forEach(child -> typeAst.addChild(visit(child)));
+
+        return methodDef;
+    }
+
+    @Override
+    public DetailAstImpl visitMethodBody(CheckstyleJavaParser.MethodBodyContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitThrowsList(CheckstyleJavaParser.ThrowsListContext ctx) {
+        final DetailAstImpl throwsRoot = create(ctx.LITERAL_THROWS());
+        throwsRoot.addChild(visit(ctx.qualifiedNameList()));
+        return throwsRoot;
+    }
+
+    @Override
+    public DetailAstImpl visitConstructorDeclaration(
+            CheckstyleJavaParser.ConstructorDeclarationContext ctx) {
+        final DetailAstImpl constructorDeclaration = createImaginary(TokenTypes.CTOR_DEF);
+        constructorDeclaration.addChild(createModifiers(ctx.mods));
+        processChildren(constructorDeclaration, ctx.children);
+        return constructorDeclaration;
+    }
+
+    @Override
+    public DetailAstImpl visitFieldDeclaration(CheckstyleJavaParser.FieldDeclarationContext ctx) {
+        final DetailAstImpl dummyNode = new DetailAstImpl();
+        // Since the TYPE AST is built by visitVariableDeclarator(), we skip it here (child [0])
+        // We also append the SEMI token to the first child [size() - 1],
+        // until https://github.com/checkstyle/checkstyle/issues/3151
+        processChildren(dummyNode, ctx.children.subList(1, ctx.children.size() - 1));
+        dummyNode.getFirstChild().addChild(create(ctx.SEMI()));
+        return dummyNode.getFirstChild();
+    }
+
+    @Override
+    public DetailAstImpl visitInterfaceBodyDeclaration(
+            CheckstyleJavaParser.InterfaceBodyDeclarationContext ctx) {
+        final DetailAstImpl returnTree;
+        if (ctx.SEMI() == null) {
+            returnTree = visit(ctx.interfaceMemberDeclaration());
+        }
+        else {
+            returnTree = create(ctx.SEMI());
+        }
+        return returnTree;
+    }
+
+    @Override
+    public DetailAstImpl visitInterfaceMethodDeclaration(
+            CheckstyleJavaParser.InterfaceMethodDeclarationContext ctx) {
+        final DetailAstImpl methodDef = createImaginary(TokenTypes.METHOD_DEF);
+        methodDef.addChild(createModifiers(ctx.mods));
+
+        // Process all children except C style array declarators and modifiers
+        final List<ParseTree> children = ctx.children
+                .stream()
+                .filter(child -> !(child instanceof CheckstyleJavaParser.ArrayDeclaratorContext))
+                .collect(Collectors.toList());
+        processChildren(methodDef, children);
+
+        // We add C style array declarator brackets to TYPE ast
+        final DetailAstImpl typeAst = (DetailAstImpl) methodDef.findFirstToken(TokenTypes.TYPE);
+        ctx.cStyleArrDec.forEach(child -> typeAst.addChild(visit(child)));
+
+        return methodDef;
+    }
+
+    @Override
+    public DetailAstImpl visitVariableDeclarators(
+            CheckstyleJavaParser.VariableDeclaratorsContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitVariableDeclarator(
+            CheckstyleJavaParser.VariableDeclaratorContext ctx) {
+        final DetailAstImpl variableDef = createImaginary(TokenTypes.VARIABLE_DEF);
+        variableDef.addChild(createModifiers(ctx.mods));
+
+        final DetailAstImpl type = visit(ctx.type);
+        variableDef.addChild(type);
+        variableDef.addChild(visit(ctx.id()));
+
+        // Add C style array declarator brackets to TYPE ast
+        ctx.arrayDeclarator().forEach(child -> type.addChild(visit(child)));
+
+        // If this is an assignment statement, ASSIGN becomes the parent of EXPR
+        if (ctx.ASSIGN() != null) {
+            final DetailAstImpl assign = create(ctx.ASSIGN());
+            variableDef.addChild(assign);
+            assign.addChild(visit(ctx.variableInitializer()));
+        }
+        return variableDef;
+    }
+
+    @Override
+    public DetailAstImpl visitVariableDeclaratorId(
+            CheckstyleJavaParser.VariableDeclaratorIdContext ctx) {
+        final DetailAstImpl root = new DetailAstImpl();
+        root.addChild(createModifiers(ctx.mods));
+        final DetailAstImpl type = visit(ctx.type);
+        root.addChild(type);
+
+        final DetailAstImpl declaratorId;
+        if (ctx.LITERAL_THIS() == null) {
+            declaratorId = visit(ctx.id());
+        }
+        else if (ctx.DOT() == null) {
+            declaratorId = create(ctx.LITERAL_THIS());
+        }
+        else {
+            declaratorId = create(ctx.DOT());
+            declaratorId.addChild(visit(ctx.id()));
+            declaratorId.addChild(create(ctx.LITERAL_THIS()));
+        }
+
+        root.addChild(declaratorId);
+        ctx.arrayDeclarator().forEach(child -> type.addChild(visit(child)));
+
+        return root.getFirstChild();
+    }
+
+    @Override
+    public DetailAstImpl visitArrayInitializer(CheckstyleJavaParser.ArrayInitializerContext ctx) {
+        final DetailAstImpl arrayInitializer = create(TokenTypes.ARRAY_INIT, ctx.start);
+        // ARRAY_INIT was child[0]
+        processChildren(arrayInitializer, ctx.children.subList(1, ctx.children.size()));
+        return arrayInitializer;
+    }
+
+    @Override
+    public DetailAstImpl visitClassOrInterfaceType(
+            CheckstyleJavaParser.ClassOrInterfaceTypeContext ctx) {
+        final DetailAstPair currentAST = new DetailAstPair();
+        DetailAstPair.addAstChild(currentAST, visit(ctx.id()));
+        DetailAstPair.addAstChild(currentAST, visit(ctx.typeArguments()));
+
+        // This is how we build the annotations/ qualified name/ type parameters tree
+        for (int i = 0; i < ctx.extended.size(); i++) {
+            final ParserRuleContext extendedContext = ctx.extended.get(i);
+            final DetailAstImpl dot = create(extendedContext.start);
+            DetailAstPair.makeAstRoot(currentAST, dot);
+            final List<ParseTree> childList = extendedContext
+                    .children.subList(1, extendedContext.children.size());
+            childList.forEach(child -> DetailAstPair.addAstChild(currentAST, visit(child)));
+        }
+
+        // Create imaginary 'TYPE' parent if specified
+        final DetailAstImpl returnTree;
+        if (ctx.createImaginaryNode) {
+            returnTree = createImaginary(TokenTypes.TYPE);
+            returnTree.addChild(currentAST.root);
+        }
+        else {
+            returnTree = currentAST.root;
+        }
+        return returnTree;
+    }
+
+    @Override
+    public DetailAstImpl visitSimpleTypeArgument(
+            CheckstyleJavaParser.SimpleTypeArgumentContext ctx) {
+        final DetailAstImpl typeArgument =
+                createImaginary(TokenTypes.TYPE_ARGUMENT);
+        typeArgument.addChild(visit(ctx.typeType()));
+        return typeArgument;
+    }
+
+    @Override
+    public DetailAstImpl visitWildCardTypeArgument(
+            CheckstyleJavaParser.WildCardTypeArgumentContext ctx) {
+        final DetailAstImpl typeArgument = createImaginary(TokenTypes.TYPE_ARGUMENT);
+        typeArgument.addChild(visit(ctx.annotations()));
+        typeArgument.addChild(create(TokenTypes.WILDCARD_TYPE,
+                (Token) ctx.QUESTION().getPayload()));
+
+        if (ctx.upperBound != null) {
+            final DetailAstImpl upperBound = create(TokenTypes.TYPE_UPPER_BOUNDS, ctx.upperBound);
+            upperBound.addChild(visit(ctx.typeType()));
+            typeArgument.addChild(upperBound);
+        }
+        else if (ctx.lowerBound != null) {
+            final DetailAstImpl lowerBound = create(TokenTypes.TYPE_LOWER_BOUNDS, ctx.lowerBound);
+            lowerBound.addChild(visit(ctx.typeType()));
+            typeArgument.addChild(lowerBound);
+        }
+
+        return typeArgument;
+    }
+
+    @Override
+    public DetailAstImpl visitQualifiedNameList(CheckstyleJavaParser.QualifiedNameListContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitFormalParameters(CheckstyleJavaParser.FormalParametersContext ctx) {
+        final DetailAstImpl lparen = create(ctx.LPAREN());
+
+        // We make a "PARAMETERS" node whether parameters exist or not
+        if (ctx.formalParameterList() == null) {
+            addLastSibling(lparen, createImaginary(TokenTypes.PARAMETERS));
+        }
+        else {
+            addLastSibling(lparen, visit(ctx.formalParameterList()));
+        }
+        addLastSibling(lparen, create(ctx.RPAREN()));
+        return lparen;
+    }
+
+    @Override
+    public DetailAstImpl visitFormalParameterList(
+            CheckstyleJavaParser.FormalParameterListContext ctx) {
+        final DetailAstImpl parameters = createImaginary(TokenTypes.PARAMETERS);
+        processChildren(parameters, ctx.children);
+        return parameters;
+    }
+
+    @Override
+    public DetailAstImpl visitFormalParameter(CheckstyleJavaParser.FormalParameterContext ctx) {
+        final DetailAstImpl variableDeclaratorId =
+                visitVariableDeclaratorId(ctx.variableDeclaratorId());
+        final DetailAstImpl parameterDef = createImaginary(TokenTypes.PARAMETER_DEF);
+        parameterDef.addChild(variableDeclaratorId);
+        return parameterDef;
+    }
+
+    @Override
+    public DetailAstImpl visitLastFormalParameter(
+            CheckstyleJavaParser.LastFormalParameterContext ctx) {
+        final DetailAstImpl parameterDef =
+                createImaginary(TokenTypes.PARAMETER_DEF);
+        parameterDef.addChild(visit(ctx.variableDeclaratorId()));
+        final DetailAstImpl ident = (DetailAstImpl) parameterDef.findFirstToken(TokenTypes.IDENT);
+        ident.addPreviousSibling(create(ctx.ELLIPSIS()));
+        // We attach annotations on ellipses in varargs to the 'TYPE' ast
+        final DetailAstImpl type = (DetailAstImpl) parameterDef.findFirstToken(TokenTypes.TYPE);
+        type.addChild(visit(ctx.annotations()));
+        return parameterDef;
+    }
+
+    @Override
+    public DetailAstImpl visitQualifiedName(CheckstyleJavaParser.QualifiedNameContext ctx) {
+        DetailAstImpl ast = visit(ctx.id(0));
+        final DetailAstPair currentAst = new DetailAstPair();
+        DetailAstPair.addAstChild(currentAst, ast);
+
+        for (int i = 1; i < ctx.children.size(); i += 2) {
+
+            // Token to become root
+            final DetailAstImpl temp = create((Token) ctx.children.get(i).getPayload());
+            DetailAstPair.makeAstRoot(currentAst, temp);
+
+            // Token to become child or next sibling
+            final Object child = ctx.children.get(i + 1).getPayload();
+            ast = visit((ParseTree) child);
+
+            DetailAstPair.addAstChild(currentAst, ast);
+        }
+        return currentAst.getRoot();
+    }
+
+    @Override
+    public DetailAstImpl visitLiteral(CheckstyleJavaParser.LiteralContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitIntegerLiteral(CheckstyleJavaParser.IntegerLiteralContext ctx) {
+        final int[] longTypes = {
+            JavaLexer.DECIMAL_LITERAL_LONG,
+            JavaLexer.HEX_LITERAL_LONG,
+            JavaLexer.OCT_LITERAL_LONG,
+            JavaLexer.BINARY_LITERAL_LONG,
+        };
+
+        final int tokenType;
+        if (TokenUtil.isOfType(ctx.start.getType(), longTypes)) {
+            tokenType = TokenTypes.NUM_LONG;
+        }
+        else {
+            tokenType = TokenTypes.NUM_INT;
+        }
+
+        return create(tokenType, ctx.start);
+    }
+
+    @Override
+    public DetailAstImpl visitFloatLiteral(CheckstyleJavaParser.FloatLiteralContext ctx) {
+        final DetailAstImpl floatLiteral;
+        if (TokenUtil.isOfType(ctx.start.getType(),
+                JavaLexer.DOUBLE_LITERAL, JavaLexer.HEX_DOUBLE_LITERAL)) {
+            floatLiteral = create(TokenTypes.NUM_DOUBLE, ctx.start);
+        }
+        else {
+            floatLiteral = create(TokenTypes.NUM_FLOAT, ctx.start);
+        }
+        return floatLiteral;
+    }
+
+    @Override
+    public DetailAstImpl visitTextBlockLiteral(CheckstyleJavaParser.TextBlockLiteralContext ctx) {
+        final DetailAstImpl textBlockLiteralBegin = create(ctx.TEXT_BLOCK_LITERAL_BEGIN());
+        textBlockLiteralBegin.addChild(create(ctx.TEXT_BLOCK_CONTENT()));
+        textBlockLiteralBegin.addChild(create(ctx.TEXT_BLOCK_LITERAL_END()));
+        return textBlockLiteralBegin;
+    }
+
+    @Override
+    public DetailAstImpl visitAnnotations(CheckstyleJavaParser.AnnotationsContext ctx) {
+        final DetailAstImpl annotations;
+
+        if (!ctx.createImaginaryNode && ctx.anno.isEmpty()) {
+            // There are no annotations, and we don't want to create the empty node
+            annotations = null;
+        }
+        else {
+            // There are annotations, or we just want the empty node
+            annotations = createImaginary(TokenTypes.ANNOTATIONS);
+            processChildren(annotations, ctx.anno);
+        }
+
+        return annotations;
+    }
+
+    @Override
+    public DetailAstImpl visitAnnotation(CheckstyleJavaParser.AnnotationContext ctx) {
+        final DetailAstImpl annotation = createImaginary(TokenTypes.ANNOTATION);
+        processChildren(annotation, ctx.children);
+        return annotation;
+    }
+
+    @Override
+    public DetailAstImpl visitElementValuePairs(CheckstyleJavaParser.ElementValuePairsContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitElementValuePair(CheckstyleJavaParser.ElementValuePairContext ctx) {
+        final DetailAstImpl elementValuePair =
+                createImaginary(TokenTypes.ANNOTATION_MEMBER_VALUE_PAIR);
+        processChildren(elementValuePair, ctx.children);
+        return elementValuePair;
+    }
+
+    @Override
+    public DetailAstImpl visitElementValue(CheckstyleJavaParser.ElementValueContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitElementValueArrayInitializer(
+            CheckstyleJavaParser.ElementValueArrayInitializerContext ctx) {
+        final DetailAstImpl arrayInit =
+                create(TokenTypes.ANNOTATION_ARRAY_INIT, (Token) ctx.LCURLY().getPayload());
+        processChildren(arrayInit, ctx.children.subList(1, ctx.children.size()));
+        return arrayInit;
+    }
+
+    @Override
+    public DetailAstImpl visitAnnotationTypeDeclaration(
+            CheckstyleJavaParser.AnnotationTypeDeclarationContext ctx) {
+        return createTypeDeclaration(ctx, TokenTypes.ANNOTATION_DEF, ctx.mods);
+    }
+
+    @Override
+    public DetailAstImpl visitAnnotationTypeBody(
+            CheckstyleJavaParser.AnnotationTypeBodyContext ctx) {
+        final DetailAstImpl objBlock = createImaginary(TokenTypes.OBJBLOCK);
+        processChildren(objBlock, ctx.children);
+        return objBlock;
+    }
+
+    @Override
+    public DetailAstImpl visitAnnotationTypeElementDeclaration(
+            CheckstyleJavaParser.AnnotationTypeElementDeclarationContext ctx) {
+        final DetailAstImpl returnTree;
+        if (ctx.SEMI() == null) {
+            returnTree = visit(ctx.annotationTypeElementRest());
+        }
+        else {
+            returnTree = create(ctx.SEMI());
+        }
+        return returnTree;
+    }
+
+    @Override
+    public DetailAstImpl visitAnnotationField(CheckstyleJavaParser.AnnotationFieldContext ctx) {
+        final DetailAstImpl dummyNode = new DetailAstImpl();
+        // Since the TYPE AST is built by visitAnnotationMethodOrConstantRest(), we skip it
+        // here (child [0])
+        processChildren(dummyNode, Collections.singletonList(ctx.children.get(1)));
+        // We also append the SEMI token to the first child [size() - 1],
+        // until https://github.com/checkstyle/checkstyle/issues/3151
+        dummyNode.getFirstChild().addChild(create(ctx.SEMI()));
+        return dummyNode.getFirstChild();
+    }
+
+    @Override
+    public DetailAstImpl visitAnnotationType(CheckstyleJavaParser.AnnotationTypeContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitAnnotationMethodRest(
+            CheckstyleJavaParser.AnnotationMethodRestContext ctx) {
+        final DetailAstImpl annotationFieldDef =
+                createImaginary(TokenTypes.ANNOTATION_FIELD_DEF);
+        annotationFieldDef.addChild(createModifiers(ctx.mods));
+        annotationFieldDef.addChild(visit(ctx.type));
+
+        // Process all children except C style array declarators
+        processChildren(annotationFieldDef, ctx.children.stream()
+                .filter(child -> !(child instanceof CheckstyleJavaParser.ArrayDeclaratorContext))
+                .collect(Collectors.toList()));
+
+        // We add C style array declarator brackets to TYPE ast
+        final DetailAstImpl typeAst =
+                (DetailAstImpl) annotationFieldDef.findFirstToken(TokenTypes.TYPE);
+        ctx.cStyleArrDec.forEach(child -> typeAst.addChild(visit(child)));
+
+        return annotationFieldDef;
+    }
+
+    @Override
+    public DetailAstImpl visitDefaultValue(CheckstyleJavaParser.DefaultValueContext ctx) {
+        final DetailAstImpl defaultValue = create(ctx.LITERAL_DEFAULT());
+        defaultValue.addChild(visit(ctx.elementValue()));
+        return defaultValue;
+    }
+
+    @Override
+    public DetailAstImpl visitConstructorBlock(CheckstyleJavaParser.ConstructorBlockContext ctx) {
+        final DetailAstImpl slist = create(TokenTypes.SLIST, ctx.start);
+        // SLIST was child [0]
+        processChildren(slist, ctx.children.subList(1, ctx.children.size()));
+        return slist;
+    }
+
+    @Override
+    public DetailAstImpl visitExplicitCtorCall(CheckstyleJavaParser.ExplicitCtorCallContext ctx) {
+        final DetailAstImpl root;
+        if (ctx.LITERAL_THIS() == null) {
+            root = create(TokenTypes.SUPER_CTOR_CALL, (Token) ctx.LITERAL_SUPER().getPayload());
+        }
+        else {
+            root = create(TokenTypes.CTOR_CALL, (Token) ctx.LITERAL_THIS().getPayload());
+        }
+        root.addChild(visit(ctx.typeArguments()));
+        root.addChild(visit(ctx.arguments()));
+        root.addChild(create(ctx.SEMI()));
+        return root;
+    }
+
+    @Override
+    public DetailAstImpl visitPrimaryCtorCall(CheckstyleJavaParser.PrimaryCtorCallContext ctx) {
+        final DetailAstImpl primaryCtorCall = create(TokenTypes.SUPER_CTOR_CALL,
+                (Token) ctx.LITERAL_SUPER().getPayload());
+        // filter 'LITERAL_SUPER'
+        processChildren(primaryCtorCall, ctx.children.stream()
+                   .filter(child -> !child.equals(ctx.LITERAL_SUPER()))
+                   .collect(Collectors.toList()));
+        return primaryCtorCall;
+    }
+
+    @Override
+    public DetailAstImpl visitBlock(CheckstyleJavaParser.BlockContext ctx) {
+        final DetailAstImpl slist = create(TokenTypes.SLIST, ctx.start);
+        // SLIST was child [0]
+        processChildren(slist, ctx.children.subList(1, ctx.children.size()));
+        return slist;
+    }
+
+    @Override
+    public DetailAstImpl visitLocalVar(CheckstyleJavaParser.LocalVarContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitBlockStat(CheckstyleJavaParser.BlockStatContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitAssertExp(CheckstyleJavaParser.AssertExpContext ctx) {
+        final DetailAstImpl assertExp = create(ctx.ASSERT());
+        // child[0] is 'ASSERT'
+        processChildren(assertExp, ctx.children.subList(1, ctx.children.size()));
+        return assertExp;
+    }
+
+    @Override
+    public DetailAstImpl visitIfStat(CheckstyleJavaParser.IfStatContext ctx) {
+        final DetailAstImpl ifStat = create(ctx.LITERAL_IF());
+        // child[0] is 'LITERAL_IF'
+        processChildren(ifStat, ctx.children.subList(1, ctx.children.size()));
+        return ifStat;
+    }
+
+    @Override
+    public DetailAstImpl visitForStat(CheckstyleJavaParser.ForStatContext ctx) {
+        final DetailAstImpl forInit = create(ctx.start);
+        // child[0] is LITERAL_FOR
+        processChildren(forInit, ctx.children.subList(1, ctx.children.size()));
+        return forInit;
+    }
+
+    @Override
+    public DetailAstImpl visitWhileStat(CheckstyleJavaParser.WhileStatContext ctx) {
+        final DetailAstImpl whileStatement = create(ctx.start);
+        // 'LITERAL_WHILE' is child[0]
+        processChildren(whileStatement, ctx.children.subList(1, ctx.children.size()));
+        return whileStatement;
+    }
+
+    @Override
+    public DetailAstImpl visitDoStat(CheckstyleJavaParser.DoStatContext ctx) {
+        final DetailAstImpl doStatement = create(ctx.start);
+        // 'LITERAL_DO' is child[0]
+        doStatement.addChild(visit(ctx.statement()));
+        // We make 'LITERAL_WHILE' into 'DO_WHILE'
+        doStatement.addChild(create(TokenTypes.DO_WHILE, (Token) ctx.LITERAL_WHILE().getPayload()));
+        doStatement.addChild(visit(ctx.parExpression()));
+        doStatement.addChild(create(ctx.SEMI()));
+        return doStatement;
+    }
+
+    @Override
+    public DetailAstImpl visitTryStat(CheckstyleJavaParser.TryStatContext ctx) {
+        final DetailAstImpl tryStat = create(ctx.start);
+        // child[0] is 'LITERAL_TRY'
+        processChildren(tryStat, ctx.children.subList(1, ctx.children.size()));
+        return tryStat;
+    }
+
+    @Override
+    public DetailAstImpl visitTryWithResourceStat(
+            CheckstyleJavaParser.TryWithResourceStatContext ctx) {
+        final DetailAstImpl tryWithResources = create(ctx.LITERAL_TRY());
+        // child[0] is 'LITERAL_TRY'
+        processChildren(tryWithResources, ctx.children.subList(1, ctx.children.size()));
+        return tryWithResources;
+    }
+
+    @Override
+    public DetailAstImpl visitYieldStat(CheckstyleJavaParser.YieldStatContext ctx) {
+        final DetailAstImpl yieldParent = create(ctx.LITERAL_YIELD());
+        // LITERAL_YIELD is child[0]
+        processChildren(yieldParent, ctx.children.subList(1, ctx.children.size()));
+        return yieldParent;
+    }
+
+    @Override
+    public DetailAstImpl visitSyncStat(CheckstyleJavaParser.SyncStatContext ctx) {
+        final DetailAstImpl syncStatement = create(ctx.start);
+        // child[0] is 'LITERAL_SYNCHRONIZED'
+        processChildren(syncStatement, ctx.children.subList(1, ctx.children.size()));
+        return syncStatement;
+    }
+
+    @Override
+    public DetailAstImpl visitReturnStat(CheckstyleJavaParser.ReturnStatContext ctx) {
+        final DetailAstImpl returnStat = create(ctx.LITERAL_RETURN());
+        // child[0] is 'LITERAL_RETURN'
+        processChildren(returnStat, ctx.children.subList(1, ctx.children.size()));
+        return returnStat;
+    }
+
+    @Override
+    public DetailAstImpl visitThrowStat(CheckstyleJavaParser.ThrowStatContext ctx) {
+        final DetailAstImpl throwStat = create(ctx.LITERAL_THROW());
+        // child[0] is 'LITERAL_THROW'
+        processChildren(throwStat, ctx.children.subList(1, ctx.children.size()));
+        return throwStat;
+    }
+
+    @Override
+    public DetailAstImpl visitBreakStat(CheckstyleJavaParser.BreakStatContext ctx) {
+        final DetailAstImpl literalBreak = create(ctx.LITERAL_BREAK());
+        // child[0] is 'LITERAL_BREAK'
+        processChildren(literalBreak, ctx.children.subList(1, ctx.children.size()));
+        return literalBreak;
+    }
+
+    @Override
+    public DetailAstImpl visitContinueStat(CheckstyleJavaParser.ContinueStatContext ctx) {
+        final DetailAstImpl continueStat = create(ctx.LITERAL_CONTINUE());
+        // child[0] is 'LITERAL_CONTINUE'
+        processChildren(continueStat, ctx.children.subList(1, ctx.children.size()));
+        return continueStat;
+    }
+
+    @Override
+    public DetailAstImpl visitEmptyStat(CheckstyleJavaParser.EmptyStatContext ctx) {
+        return create(TokenTypes.EMPTY_STAT, ctx.start);
+    }
+
+    @Override
+    public DetailAstImpl visitExpStat(CheckstyleJavaParser.ExpStatContext ctx) {
+        final DetailAstImpl expStatRoot = visit(ctx.statementExpression);
+        addLastSibling(expStatRoot, create(ctx.SEMI()));
+        return expStatRoot;
+    }
+
+    @Override
+    public DetailAstImpl visitLabelStat(CheckstyleJavaParser.LabelStatContext ctx) {
+        final DetailAstImpl labelStat = create(TokenTypes.LABELED_STAT,
+                (Token) ctx.COLON().getPayload());
+        labelStat.addChild(visit(ctx.id()));
+        labelStat.addChild(visit(ctx.statement()));
+        return labelStat;
+    }
+
+    @Override
+    public DetailAstImpl visitSwitchExpressionOrStatement(
+            CheckstyleJavaParser.SwitchExpressionOrStatementContext ctx) {
+        final DetailAstImpl switchStat = create(ctx.LITERAL_SWITCH());
+        switchStat.addChild(visit(ctx.parExpression()));
+        switchStat.addChild(create(ctx.LCURLY()));
+        switchStat.addChild(visit(ctx.switchBlock()));
+        switchStat.addChild(create(ctx.RCURLY()));
+        return switchStat;
+    }
+
+    @Override
+    public DetailAstImpl visitSwitchRules(CheckstyleJavaParser.SwitchRulesContext ctx) {
+        final DetailAstImpl dummyRoot = new DetailAstImpl();
+        ctx.switchLabeledRule().forEach(switchLabeledRuleContext -> {
+            final DetailAstImpl switchRule = visit(switchLabeledRuleContext);
+            final DetailAstImpl switchRuleParent = createImaginary(TokenTypes.SWITCH_RULE);
+            switchRuleParent.addChild(switchRule);
+            dummyRoot.addChild(switchRuleParent);
+        });
+        return dummyRoot.getFirstChild();
+    }
+
+    @Override
+    public DetailAstImpl visitSwitchBlocks(CheckstyleJavaParser.SwitchBlocksContext ctx) {
+        final DetailAstImpl dummyRoot = new DetailAstImpl();
+        ctx.groups.forEach(group -> dummyRoot.addChild(visit(group)));
+
+        // Add any empty switch labels to end of statement in one 'CASE_GROUP'
+        if (!ctx.emptyLabels.isEmpty()) {
+            final DetailAstImpl emptyLabelParent =
+                    createImaginary(TokenTypes.CASE_GROUP);
+            ctx.emptyLabels.forEach(label -> emptyLabelParent.addChild(visit(label)));
+            dummyRoot.addChild(emptyLabelParent);
+        }
+        return dummyRoot.getFirstChild();
+    }
+
+    @Override
+    public DetailAstImpl visitSwitchLabeledExpression(
+            CheckstyleJavaParser.SwitchLabeledExpressionContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitSwitchLabeledBlock(
+            CheckstyleJavaParser.SwitchLabeledBlockContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitSwitchLabeledThrow(
+            CheckstyleJavaParser.SwitchLabeledThrowContext ctx) {
+        final DetailAstImpl switchLabel = visit(ctx.switchLabel());
+        addLastSibling(switchLabel, create(ctx.LAMBDA()));
+        final DetailAstImpl literalThrow = create(ctx.LITERAL_THROW());
+        literalThrow.addChild(visit(ctx.expression()));
+        literalThrow.addChild(create(ctx.SEMI()));
+        addLastSibling(switchLabel, literalThrow);
+        return switchLabel;
+    }
+
+    @Override
+    public DetailAstImpl visitElseStat(CheckstyleJavaParser.ElseStatContext ctx) {
+        final DetailAstImpl elseStat = create(ctx.LITERAL_ELSE());
+        // child[0] is 'LITERAL_ELSE'
+        processChildren(elseStat, ctx.children.subList(1, ctx.children.size()));
+        return elseStat;
+    }
+
+    @Override
+    public DetailAstImpl visitCatchClause(CheckstyleJavaParser.CatchClauseContext ctx) {
+        final DetailAstImpl catchClause = create(TokenTypes.LITERAL_CATCH,
+                (Token) ctx.LITERAL_CATCH().getPayload());
+        // 'LITERAL_CATCH' is child[0]
+        processChildren(catchClause, ctx.children.subList(1, ctx.children.size()));
+        return catchClause;
+    }
+
+    @Override
+    public DetailAstImpl visitCatchParameter(CheckstyleJavaParser.CatchParameterContext ctx) {
+        final DetailAstImpl catchParameterDef = createImaginary(TokenTypes.PARAMETER_DEF);
+        catchParameterDef.addChild(createModifiers(ctx.mods));
+        // filter mods
+        processChildren(catchParameterDef, ctx.children.stream()
+                .filter(child -> !(child instanceof CheckstyleJavaParser.VariableModifierContext))
+                .collect(Collectors.toList()));
+        return catchParameterDef;
+    }
+
+    @Override
+    public DetailAstImpl visitCatchType(CheckstyleJavaParser.CatchTypeContext ctx) {
+        final DetailAstImpl type = createImaginary(TokenTypes.TYPE);
+        processChildren(type, ctx.children);
+        return type;
+    }
+
+    @Override
+    public DetailAstImpl visitFinallyBlock(CheckstyleJavaParser.FinallyBlockContext ctx) {
+        final DetailAstImpl finallyBlock = create(ctx.LITERAL_FINALLY());
+        // child[0] is 'LITERAL_FINALLY'
+        processChildren(finallyBlock, ctx.children.subList(1, ctx.children.size()));
+        return finallyBlock;
+    }
+
+    @Override
+    public DetailAstImpl visitResourceSpecification(
+            CheckstyleJavaParser.ResourceSpecificationContext ctx) {
+        final DetailAstImpl resourceSpecification =
+                createImaginary(TokenTypes.RESOURCE_SPECIFICATION);
+        processChildren(resourceSpecification, ctx.children);
+        return resourceSpecification;
+    }
+
+    @Override
+    public DetailAstImpl visitResources(CheckstyleJavaParser.ResourcesContext ctx) {
+        final DetailAstImpl firstResource = visit(ctx.resource(0));
+        final DetailAstImpl resources = createImaginary(TokenTypes.RESOURCES);
+        resources.addChild(firstResource);
+        processChildren(resources, ctx.children.subList(1, ctx.children.size()));
+        return resources;
+    }
+
+    @Override
+    public DetailAstImpl visitResourceDeclaration(
+            CheckstyleJavaParser.ResourceDeclarationContext ctx) {
+        final DetailAstImpl resource = createImaginary(TokenTypes.RESOURCE);
+        resource.addChild(visit(ctx.variableDeclaratorId()));
+
+        final DetailAstImpl assign = create(ctx.ASSIGN());
+        resource.addChild(assign);
+        assign.addChild(visit(ctx.expression()));
+        return resource;
+    }
+
+    @Override
+    public DetailAstImpl visitVariableAccess(CheckstyleJavaParser.VariableAccessContext ctx) {
+        final DetailAstImpl resource;
+        if (ctx.accessList.isEmpty()) {
+            resource = createImaginary(TokenTypes.RESOURCE);
+            resource.addChild(visit(ctx.id()));
+        }
+        else {
+            final DetailAstPair currentAst = new DetailAstPair();
+            ctx.accessList.forEach(fieldAccess -> {
+                DetailAstPair.addAstChild(currentAst, visit(fieldAccess.expr()));
+                DetailAstPair.makeAstRoot(currentAst, create(fieldAccess.DOT()));
+            });
+            resource = createImaginary(TokenTypes.RESOURCE);
+            resource.addChild(currentAst.root);
+            if (ctx.LITERAL_THIS() == null) {
+                resource.getFirstChild().addChild(visit(ctx.id()));
+            }
+            else {
+                resource.getFirstChild().addChild(create(ctx.LITERAL_THIS()));
+            }
+        }
+        return resource;
+    }
+
+    @Override
+    public DetailAstImpl visitSwitchBlockStatementGroup(
+            CheckstyleJavaParser.SwitchBlockStatementGroupContext ctx) {
+        final DetailAstImpl caseGroup = createImaginary(TokenTypes.CASE_GROUP);
+        processChildren(caseGroup, ctx.switchLabel());
+        final DetailAstImpl sList = createImaginary(TokenTypes.SLIST);
+        processChildren(sList, ctx.slists);
+        caseGroup.addChild(sList);
+        return caseGroup;
+    }
+
+    @Override
+    public DetailAstImpl visitCaseLabel(CheckstyleJavaParser.CaseLabelContext ctx) {
+        final DetailAstImpl caseLabel = create(ctx.LITERAL_CASE());
+        // child [0] is 'LITERAL_CASE'
+        processChildren(caseLabel, ctx.children.subList(1, ctx.children.size()));
+        return caseLabel;
+    }
+
+    @Override
+    public DetailAstImpl visitDefaultLabel(CheckstyleJavaParser.DefaultLabelContext ctx) {
+        final DetailAstImpl defaultLabel = create(ctx.LITERAL_DEFAULT());
+        if (ctx.COLON() != null) {
+            defaultLabel.addChild(create(ctx.COLON()));
+        }
+        return defaultLabel;
+    }
+
+    @Override
+    public DetailAstImpl visitCaseConstants(CheckstyleJavaParser.CaseConstantsContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitEnhancedFor(CheckstyleJavaParser.EnhancedForContext ctx) {
+        final DetailAstImpl leftParen = create(ctx.LPAREN());
+        final DetailAstImpl enhancedForControl =
+                 visit(ctx.enhancedForControl());
+        final DetailAstImpl forEachClause = createImaginary(TokenTypes.FOR_EACH_CLAUSE);
+        forEachClause.addChild(enhancedForControl);
+        addLastSibling(leftParen, forEachClause);
+        addLastSibling(leftParen, create(ctx.RPAREN()));
+        return leftParen;
+    }
+
+    @Override
+    public DetailAstImpl visitForFor(CheckstyleJavaParser.ForForContext ctx) {
+        final DetailAstImpl dummyRoot = new DetailAstImpl();
+        dummyRoot.addChild(create(ctx.LPAREN()));
+
+        if (ctx.forInit() == null) {
+            final DetailAstImpl imaginaryForInitParent =
+                    createImaginary(TokenTypes.FOR_INIT);
+            dummyRoot.addChild(imaginaryForInitParent);
+        }
+        else {
+            dummyRoot.addChild(visit(ctx.forInit()));
+        }
+
+        dummyRoot.addChild(create(ctx.SEMI(0)));
+
+        final DetailAstImpl forCondParent = createImaginary(TokenTypes.FOR_CONDITION);
+        forCondParent.addChild(visit(ctx.forCond));
+        dummyRoot.addChild(forCondParent);
+        dummyRoot.addChild(create(ctx.SEMI(1)));
+
+        final DetailAstImpl forItParent = createImaginary(TokenTypes.FOR_ITERATOR);
+        forItParent.addChild(visit(ctx.forUpdate));
+        dummyRoot.addChild(forItParent);
+
+        dummyRoot.addChild(create(ctx.RPAREN()));
+
+        return dummyRoot.getFirstChild();
+    }
+
+    @Override
+    public DetailAstImpl visitForInit(CheckstyleJavaParser.ForInitContext ctx) {
+        final DetailAstImpl forInit = createImaginary(TokenTypes.FOR_INIT);
+        processChildren(forInit, ctx.children);
+        return forInit;
+    }
+
+    @Override
+    public DetailAstImpl visitEnhancedForControl(
+            CheckstyleJavaParser.EnhancedForControlContext ctx) {
+        final DetailAstImpl variableDeclaratorId =
+                 visit(ctx.variableDeclaratorId());
+        final DetailAstImpl variableDef = createImaginary(TokenTypes.VARIABLE_DEF);
+        variableDef.addChild(variableDeclaratorId);
+
+        addLastSibling(variableDef, create(ctx.COLON()));
+        addLastSibling(variableDef, visit(ctx.expression()));
+        return variableDef;
+    }
+
+    @Override
+    public DetailAstImpl visitParExpression(CheckstyleJavaParser.ParExpressionContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitExpressionList(CheckstyleJavaParser.ExpressionListContext ctx) {
+        final DetailAstImpl elist = createImaginary(TokenTypes.ELIST);
+        processChildren(elist, ctx.children);
+        return elist;
+    }
+
+    @Override
+    public DetailAstImpl visitExpression(CheckstyleJavaParser.ExpressionContext ctx) {
+        final DetailAstImpl expression = visit(ctx.expr());
+        DetailAstImpl exprRoot = createImaginary(TokenTypes.EXPR);
+        exprRoot.addChild(expression);
+
+        final int[] expressionsWithNoExprRoot = {
+            TokenTypes.CTOR_CALL,
+            TokenTypes.SUPER_CTOR_CALL,
+            TokenTypes.LAMBDA,
+        };
+
+        if (TokenUtil.isOfType(expression, expressionsWithNoExprRoot)) {
+            exprRoot = exprRoot.getFirstChild();
+        }
+
+        return exprRoot;
+    }
+
+    @Override
+    public DetailAstImpl visitRefOp(CheckstyleJavaParser.RefOpContext ctx) {
+        final DetailAstImpl bop = create(ctx.bop);
+        final DetailAstImpl leftChild = visit(ctx.expr());
+        final DetailAstImpl rightChild = create(TokenTypes.IDENT, ctx.stop);
+        bop.addChild(leftChild);
+        bop.addChild(rightChild);
+        return bop;
+    }
+
+    @Override
+    public DetailAstImpl visitSuperExp(CheckstyleJavaParser.SuperExpContext ctx) {
+        final DetailAstImpl bop = create(ctx.bop);
+        bop.addChild(visit(ctx.expr()));
+        bop.addChild(create(ctx.LITERAL_SUPER()));
+        DetailAstImpl superSuffixParent = visit(ctx.superSuffix());
+
+        if (superSuffixParent == null) {
+            superSuffixParent = bop;
+        }
+        else {
+            DetailAstImpl firstChild = superSuffixParent.getFirstChild();
+            while (firstChild.getFirstChild() != null) {
+                firstChild = firstChild.getFirstChild();
+            }
+            firstChild.addPreviousSibling(bop);
+        }
+
+        return superSuffixParent;
+    }
+
+    @Override
+    public DetailAstImpl visitInstanceOfExp(CheckstyleJavaParser.InstanceOfExpContext ctx) {
+        final DetailAstImpl literalInstanceOf = create(ctx.LITERAL_INSTANCEOF());
+        literalInstanceOf.addChild(visit(ctx.expr()));
+        literalInstanceOf.addChild(visit(ctx.children.get(2)));
+        return literalInstanceOf;
+    }
+
+    @Override
+    public DetailAstImpl visitBitShift(CheckstyleJavaParser.BitShiftContext ctx) {
+        final DetailAstImpl shiftOperation;
+
+        // We determine the type of shift operation in the parser, instead of the
+        // lexer as in older grammars. This makes it easier to parse type parameters
+        // and less than/ greater than operators in general.
+        if (ctx.LT().size() == LEFT_SHIFT.length()) {
+            shiftOperation = create(TokenTypes.SL, (Token) ctx.LT(0).getPayload());
+            shiftOperation.setText(LEFT_SHIFT);
+        }
+        else if (ctx.GT().size() == UNSIGNED_RIGHT_SHIFT.length()) {
+            shiftOperation = create(TokenTypes.BSR, (Token) ctx.GT(0).getPayload());
+            shiftOperation.setText(UNSIGNED_RIGHT_SHIFT);
+        }
+        else {
+            shiftOperation = create(TokenTypes.SR, (Token) ctx.GT(0).getPayload());
+            shiftOperation.setText(RIGHT_SHIFT);
+        }
+
+        shiftOperation.addChild(visit(ctx.expr(0)));
+        shiftOperation.addChild(visit(ctx.expr(1)));
+        return shiftOperation;
+    }
+
+    @Override
+    public DetailAstImpl visitNewExp(CheckstyleJavaParser.NewExpContext ctx) {
+        final DetailAstImpl newExp = create(ctx.LITERAL_NEW());
+        // child [0] is LITERAL_NEW
+        processChildren(newExp, ctx.children.subList(1, ctx.children.size()));
+        return newExp;
+    }
+
+    @Override
+    public DetailAstImpl visitPrefix(CheckstyleJavaParser.PrefixContext ctx) {
+        final int tokenType;
+        switch (ctx.prefix.getType()) {
+            case JavaLexer.PLUS:
+                tokenType = TokenTypes.UNARY_PLUS;
+                break;
+            case JavaLexer.MINUS:
+                tokenType = TokenTypes.UNARY_MINUS;
+                break;
+            default:
+                tokenType = ctx.prefix.getType();
+        }
+        final DetailAstImpl prefix = create(tokenType, ctx.prefix);
+        prefix.addChild(visit(ctx.expr()));
+        return prefix;
+    }
+
+    @Override
+    public DetailAstImpl visitCastExp(CheckstyleJavaParser.CastExpContext ctx) {
+        final DetailAstImpl cast = create(TokenTypes.TYPECAST, (Token) ctx.LPAREN().getPayload());
+        // child [0] is LPAREN
+        processChildren(cast, ctx.children.subList(1, ctx.children.size()));
+        return cast;
+    }
+
+    @Override
+    public DetailAstImpl visitIndexOp(CheckstyleJavaParser.IndexOpContext ctx) {
+        // LBRACK -> INDEX_OP is root of this AST
+        final DetailAstImpl indexOp = create(TokenTypes.INDEX_OP,
+                (Token) ctx.LBRACK().getPayload());
+
+        // add expression(IDENT) on LHS
+        indexOp.addChild(visit(ctx.expr(0)));
+
+        // create imaginary node for expression on RHS
+        final DetailAstImpl expr = visit(ctx.expr(1));
+        final DetailAstImpl imaginaryExpr = createImaginary(TokenTypes.EXPR);
+        imaginaryExpr.addChild(expr);
+        indexOp.addChild(imaginaryExpr);
+
+        // complete AST by adding RBRACK
+        indexOp.addChild(create(ctx.RBRACK()));
+        return indexOp;
+    }
+
+    @Override
+    public DetailAstImpl visitInvOp(CheckstyleJavaParser.InvOpContext ctx) {
+        final DetailAstPair currentAst = new DetailAstPair();
+
+        final DetailAstImpl returnAst = visit(ctx.expr());
+        DetailAstPair.addAstChild(currentAst, returnAst);
+        DetailAstPair.makeAstRoot(currentAst, create(ctx.bop));
+
+        DetailAstPair.addAstChild(currentAst,
+                 visit(ctx.nonWildcardTypeArguments()));
+        DetailAstPair.addAstChild(currentAst, visit(ctx.id()));
+        final DetailAstImpl lparen = create(TokenTypes.METHOD_CALL,
+                (Token) ctx.LPAREN().getPayload());
+        DetailAstPair.makeAstRoot(currentAst, lparen);
+
+        // We always add an 'ELIST' node
+        final DetailAstImpl expressionList = Optional.ofNullable(visit(ctx.expressionList()))
+                .orElse(createImaginary(TokenTypes.ELIST));
+
+        DetailAstPair.addAstChild(currentAst, expressionList);
+        DetailAstPair.addAstChild(currentAst, create(ctx.RPAREN()));
+
+        return currentAst.root;
+    }
+
+    @Override
+    public DetailAstImpl visitInitExp(CheckstyleJavaParser.InitExpContext ctx) {
+        final DetailAstImpl dot = create(ctx.bop);
+        dot.addChild(visit(ctx.expr()));
+        final DetailAstImpl literalNew = create(ctx.LITERAL_NEW());
+        literalNew.addChild(visit(ctx.nonWildcardTypeArguments()));
+        literalNew.addChild(visit(ctx.innerCreator()));
+        dot.addChild(literalNew);
+        return dot;
+    }
+
+    @Override
+    public DetailAstImpl visitSimpleMethodCall(CheckstyleJavaParser.SimpleMethodCallContext ctx) {
+        final DetailAstImpl methodCall = create(TokenTypes.METHOD_CALL,
+                (Token) ctx.LPAREN().getPayload());
+        methodCall.addChild(visit(ctx.id()));
+        // We always add an 'ELIST' node
+        final DetailAstImpl expressionList = Optional.ofNullable(visit(ctx.expressionList()))
+                .orElse(createImaginary(TokenTypes.ELIST));
+
+        methodCall.addChild(expressionList);
+        methodCall.addChild(create((Token) ctx.RPAREN().getPayload()));
+        return methodCall;
+    }
+
+    @Override
+    public DetailAstImpl visitLambdaExp(CheckstyleJavaParser.LambdaExpContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitThisExp(CheckstyleJavaParser.ThisExpContext ctx) {
+        final DetailAstImpl bop = create(ctx.bop);
+        bop.addChild(visit(ctx.expr()));
+        bop.addChild(create(ctx.LITERAL_THIS()));
+        return bop;
+    }
+
+    @Override
+    public DetailAstImpl visitPrimaryExp(CheckstyleJavaParser.PrimaryExpContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitPostfix(CheckstyleJavaParser.PostfixContext ctx) {
+        final DetailAstImpl postfix;
+        if (ctx.postfix.getType() == JavaLexer.INC) {
+            postfix = create(TokenTypes.POST_INC, ctx.postfix);
+        }
+        else {
+            postfix = create(TokenTypes.POST_DEC, ctx.postfix);
+        }
+        postfix.addChild(visit(ctx.expr()));
+        return postfix;
+    }
+
+    @Override
+    public DetailAstImpl visitMethodRef(CheckstyleJavaParser.MethodRefContext ctx) {
+        final DetailAstImpl doubleColon = create(TokenTypes.METHOD_REF,
+                (Token) ctx.DOUBLE_COLON().getPayload());
+        final List<ParseTree> children = ctx.children.stream()
+                .filter(child -> !child.equals(ctx.DOUBLE_COLON()))
+                .collect(Collectors.toList());
+        processChildren(doubleColon, children);
+        return doubleColon;
+    }
+
+    @Override
+    public DetailAstImpl visitTernaryOp(CheckstyleJavaParser.TernaryOpContext ctx) {
+        final DetailAstImpl root = create(ctx.QUESTION());
+        processChildren(root, ctx.children.stream()
+                .filter(child -> !child.equals(ctx.QUESTION()))
+                .collect(Collectors.toList()));
+        return root;
+    }
+
+    @Override
+    public DetailAstImpl visitBinOp(CheckstyleJavaParser.BinOpContext ctx) {
+        final DetailAstImpl bop = create(ctx.bop);
+
+        // To improve performance, we iterate through binary operations
+        // since they are frequently deeply nested.
+        final List<CheckstyleJavaParser.BinOpContext> binOpList = new ArrayList<>();
+        ParseTree firstExpression = ctx.expr(0);
+        while (firstExpression instanceof CheckstyleJavaParser.BinOpContext) {
+            // Get all nested binOps
+            binOpList.add((CheckstyleJavaParser.BinOpContext) firstExpression);
+            firstExpression = ((CheckstyleJavaParser.BinOpContext) firstExpression).expr(0);
+        }
+
+        if (binOpList.isEmpty()) {
+            final DetailAstImpl leftChild = visit(ctx.children.get(0));
+            bop.addChild(leftChild);
+        }
+        else {
+            // Map all descendants to individual AST's since we can parallelize this
+            // operation
+            final Queue<DetailAstImpl> descendantList = binOpList.parallelStream()
+                    .map(this::getInnerBopAst)
+                    .collect(Collectors.toCollection(ConcurrentLinkedQueue::new));
+
+            bop.addChild(descendantList.poll());
+            DetailAstImpl pointer = bop.getFirstChild();
+            // Build tree
+            for (DetailAstImpl descendant : descendantList) {
+                pointer.getFirstChild().addPreviousSibling(descendant);
+                pointer = descendant;
+            }
+        }
+
+        bop.addChild(visit(ctx.children.get(2)));
+        return bop;
+    }
+
+    /**
+     * Builds the binary operation (binOp) AST.
+     *
+     * @param descendant the BinOpContext to build AST from
+     * @return binOp AST
+     */
+    private DetailAstImpl getInnerBopAst(CheckstyleJavaParser.BinOpContext descendant) {
+        final DetailAstImpl innerBop = create(descendant.bop);
+        if (!(descendant.expr(0) instanceof CheckstyleJavaParser.BinOpContext)) {
+            innerBop.addChild(visit(descendant.expr(0)));
+        }
+        innerBop.addChild(visit(descendant.expr(1)));
+        return innerBop;
+    }
+
+    @Override
+    public DetailAstImpl visitMethodCall(CheckstyleJavaParser.MethodCallContext ctx) {
+        final DetailAstImpl methodCall = create(TokenTypes.METHOD_CALL,
+                (Token) ctx.LPAREN().getPayload());
+        // We always add an 'ELIST' node
+        final DetailAstImpl expressionList = Optional.ofNullable(visit(ctx.expressionList()))
+                .orElse(createImaginary(TokenTypes.ELIST));
+
+        final DetailAstImpl dot = create(ctx.DOT());
+        dot.addChild(visit(ctx.expr()));
+        dot.addChild(visit(ctx.id()));
+        methodCall.addChild(dot);
+        methodCall.addChild(expressionList);
+        methodCall.addChild(create((Token) ctx.RPAREN().getPayload()));
+        return methodCall;
+    }
+
+    @Override
+    public DetailAstImpl visitTypeCastParameters(
+            CheckstyleJavaParser.TypeCastParametersContext ctx) {
+        final DetailAstImpl typeType = visit(ctx.typeType(0));
+        for (int i = 0; i < ctx.BAND().size(); i++) {
+            addLastSibling(typeType, create(TokenTypes.TYPE_EXTENSION_AND,
+                                (Token) ctx.BAND(i).getPayload()));
+            addLastSibling(typeType, visit(ctx.typeType(i + 1)));
+        }
+        return typeType;
+    }
+
+    @Override
+    public DetailAstImpl visitLambdaExpression(CheckstyleJavaParser.LambdaExpressionContext ctx) {
+        final DetailAstImpl lambda = create(ctx.LAMBDA());
+        lambda.addChild(visit(ctx.lambdaParameters()));
+        lambda.addChild(visit(ctx.lambdaBody()));
+        return lambda;
+    }
+
+    @Override
+    public DetailAstImpl visitSingleLambdaParam(CheckstyleJavaParser.SingleLambdaParamContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitFormalLambdaParam(CheckstyleJavaParser.FormalLambdaParamContext ctx) {
+        final DetailAstImpl lparen = create(ctx.LPAREN());
+
+        // We add an 'PARAMETERS' node here whether it exists or not
+        final DetailAstImpl parameters = Optional.ofNullable(visit(ctx.formalParameterList()))
+                .orElse(createImaginary(TokenTypes.PARAMETERS));
+        addLastSibling(lparen, parameters);
+        addLastSibling(lparen, create(ctx.RPAREN()));
+        return lparen;
+    }
+
+    @Override
+    public DetailAstImpl visitMultiLambdaParam(CheckstyleJavaParser.MultiLambdaParamContext ctx) {
+        final DetailAstImpl lparen = create(ctx.LPAREN());
+        addLastSibling(lparen, visit(ctx.multiLambdaParams()));
+        addLastSibling(lparen, create(ctx.RPAREN()));
+        return lparen;
+    }
+
+    @Override
+    public DetailAstImpl visitMultiLambdaParams(CheckstyleJavaParser.MultiLambdaParamsContext ctx) {
+        final DetailAstImpl parameters = createImaginary(TokenTypes.PARAMETERS);
+        parameters.addChild(createLambdaParameter(ctx.id(0)));
+
+        for (int i = 0; i < ctx.COMMA().size(); i++) {
+            parameters.addChild(create(ctx.COMMA(i)));
+            parameters.addChild(createLambdaParameter(ctx.id(i + 1)));
+        }
+        return parameters;
+    }
+
+    /**
+     * Creates a 'PARAMETER_DEF' node for a lambda expression, with
+     * imaginary modifier and type nodes.
+     *
+     * @param ctx the IdContext to create imaginary nodes for
+     * @return DetailAstImpl of lambda parameter
+     */
+    private DetailAstImpl createLambdaParameter(CheckstyleJavaParser.IdContext ctx) {
+        final DetailAstImpl ident = visitId(ctx);
+        final DetailAstImpl parameter = createImaginary(TokenTypes.PARAMETER_DEF);
+        final DetailAstImpl modifiers = createImaginary(TokenTypes.MODIFIERS);
+        final DetailAstImpl type = createImaginary(TokenTypes.TYPE);
+        parameter.addChild(modifiers);
+        parameter.addChild(type);
+        parameter.addChild(ident);
+        return parameter;
+    }
+
+    @Override
+    public DetailAstImpl visitParenPrimary(CheckstyleJavaParser.ParenPrimaryContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitTokenPrimary(CheckstyleJavaParser.TokenPrimaryContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitClassRefPrimary(CheckstyleJavaParser.ClassRefPrimaryContext ctx) {
+        final DetailAstImpl dot = create(ctx.DOT());
+        final DetailAstImpl primaryTypeNoArray = visit(ctx.type);
+        dot.addChild(primaryTypeNoArray);
+        if (TokenUtil.isOfType(primaryTypeNoArray, TokenTypes.DOT)) {
+            // We append '[]' to the qualified name 'TYPE' `ast
+            ctx.arrayDeclarator()
+                    .forEach(child -> primaryTypeNoArray.addChild(visit(child)));
+        }
+        else {
+            ctx.arrayDeclarator()
+                    .forEach(child -> addLastSibling(primaryTypeNoArray, visit(child)));
+        }
+        dot.addChild(create(ctx.LITERAL_CLASS()));
+        return dot;
+    }
+
+    @Override
+    public DetailAstImpl visitPrimitivePrimary(CheckstyleJavaParser.PrimitivePrimaryContext ctx) {
+        final DetailAstImpl dot = create(ctx.DOT());
+        final DetailAstImpl primaryTypeNoArray = visit(ctx.type);
+        dot.addChild(primaryTypeNoArray);
+        ctx.arrayDeclarator().forEach(child -> dot.addChild(visit(child)));
+        dot.addChild(create(ctx.LITERAL_CLASS()));
+        return dot;
+    }
+
+    @Override
+    public DetailAstImpl visitCreator(CheckstyleJavaParser.CreatorContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitCreatedNameObject(CheckstyleJavaParser.CreatedNameObjectContext ctx) {
+        final DetailAstPair currentAST = new DetailAstPair();
+        DetailAstPair.addAstChild(currentAST, visit(ctx.id()));
+        DetailAstPair.addAstChild(currentAST, visit(ctx.typeArgumentsOrDiamond()));
+
+        // This is how we build the type arguments/ qualified name tree
+        for (int i = 0; i < ctx.extended.size(); i++) {
+            final ParserRuleContext extendedContext = ctx.extended.get(i);
+            final DetailAstImpl dot = create(extendedContext.start);
+            DetailAstPair.makeAstRoot(currentAST, dot);
+            final List<ParseTree> childList = extendedContext
+                    .children.subList(1, extendedContext.children.size());
+            processChildren(dot, childList);
+        }
+
+        return currentAST.root;
+    }
+
+    @Override
+    public DetailAstImpl visitCreatedNamePrimitive(
+            CheckstyleJavaParser.CreatedNamePrimitiveContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitInnerCreator(CheckstyleJavaParser.InnerCreatorContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitArrayCreatorRest(CheckstyleJavaParser.ArrayCreatorRestContext ctx) {
+        final DetailAstImpl arrayDeclarator = create(TokenTypes.ARRAY_DECLARATOR,
+                (Token) ctx.LBRACK().getPayload());
+        // child[0] is LBRACK
+        for (int i = 1; i < ctx.children.size(); i++) {
+            if (ctx.children.get(i) == ctx.RBRACK()) {
+                arrayDeclarator.addChild(create(ctx.RBRACK()));
+            }
+            else if (ctx.children.get(i) == ctx.expression()) {
+                // Handle '[8]', etc.
+                arrayDeclarator.addChild(visit(ctx.expression()));
+            }
+            else {
+                addLastSibling(arrayDeclarator, visit(ctx.children.get(i)));
+            }
+        }
+        return arrayDeclarator;
+    }
+
+    @Override
+    public DetailAstImpl visitBracketsWithExp(CheckstyleJavaParser.BracketsWithExpContext ctx) {
+        final DetailAstImpl dummyRoot = new DetailAstImpl();
+        dummyRoot.addChild(visit(ctx.annotations()));
+        final DetailAstImpl arrayDeclarator =
+                create(TokenTypes.ARRAY_DECLARATOR, (Token) ctx.LBRACK().getPayload());
+        arrayDeclarator.addChild(visit(ctx.expression()));
+        arrayDeclarator.addChild(create(ctx.stop));
+        dummyRoot.addChild(arrayDeclarator);
+        return dummyRoot.getFirstChild();
+    }
+
+    @Override
+    public DetailAstImpl visitClassCreatorRest(CheckstyleJavaParser.ClassCreatorRestContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitDiamond(CheckstyleJavaParser.DiamondContext ctx) {
+        final DetailAstImpl typeArguments =
+                createImaginary(TokenTypes.TYPE_ARGUMENTS);
+        typeArguments.addChild(create(TokenTypes.GENERIC_START,
+                (Token) ctx.LT().getPayload()));
+        typeArguments.addChild(create(TokenTypes.GENERIC_END,
+                (Token) ctx.GT().getPayload()));
+        return typeArguments;
+    }
+
+    @Override
+    public DetailAstImpl visitTypeArgs(CheckstyleJavaParser.TypeArgsContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitNonWildcardDiamond(
+            CheckstyleJavaParser.NonWildcardDiamondContext ctx) {
+        final DetailAstImpl typeArguments =
+                createImaginary(TokenTypes.TYPE_ARGUMENTS);
+        typeArguments.addChild(create(TokenTypes.GENERIC_START,
+                (Token) ctx.LT().getPayload()));
+        typeArguments.addChild(create(TokenTypes.GENERIC_END,
+                (Token) ctx.GT().getPayload()));
+        return typeArguments;
+    }
+
+    @Override
+    public DetailAstImpl visitNonWildcardTypeArguments(
+            CheckstyleJavaParser.NonWildcardTypeArgumentsContext ctx) {
+        final DetailAstImpl typeArguments = createImaginary(TokenTypes.TYPE_ARGUMENTS);
+        typeArguments.addChild(create(TokenTypes.GENERIC_START, (Token) ctx.LT().getPayload()));
+        typeArguments.addChild(visit(ctx.typeArgumentsTypeList()));
+        typeArguments.addChild(create(TokenTypes.GENERIC_END, (Token) ctx.GT().getPayload()));
+        return typeArguments;
+    }
+
+    @Override
+    public DetailAstImpl visitTypeArgumentsTypeList(
+            CheckstyleJavaParser.TypeArgumentsTypeListContext ctx) {
+        final DetailAstImpl firstIdent = visit(ctx.typeType(0));
+        final DetailAstImpl firstTypeArgument = createImaginary(TokenTypes.TYPE_ARGUMENT);
+        firstTypeArgument.addChild(firstIdent);
+
+        for (int i = 0; i < ctx.COMMA().size(); i++) {
+            addLastSibling(firstTypeArgument, create(ctx.COMMA(i)));
+            final DetailAstImpl ident = visit(ctx.typeType(i + 1));
+            final DetailAstImpl typeArgument = createImaginary(TokenTypes.TYPE_ARGUMENT);
+            typeArgument.addChild(ident);
+            addLastSibling(firstTypeArgument, typeArgument);
+        }
+        return firstTypeArgument;
+    }
+
+    @Override
+    public DetailAstImpl visitTypeList(CheckstyleJavaParser.TypeListContext ctx) {
+        return flattenedTree(ctx);
+    }
+
+    @Override
+    public DetailAstImpl visitTypeType(CheckstyleJavaParser.TypeTypeContext ctx) {
+        final DetailAstImpl type = createImaginary(TokenTypes.TYPE);
+        processChildren(type, ctx.children);
+
+        final DetailAstImpl returnTree;
+        if (ctx.createImaginaryNode) {
+            returnTree = type;
+        }
+        else {
+            returnTree = type.getFirstChild();
+        }
+        return returnTree;
+    }
+
+    @Override
+    public DetailAstImpl visitArrayDeclarator(CheckstyleJavaParser.ArrayDeclaratorContext ctx) {
+        final DetailAstImpl arrayDeclarator = create(TokenTypes.ARRAY_DECLARATOR,
+                (Token) ctx.LBRACK().getPayload());
+        arrayDeclarator.addChild(create(ctx.RBRACK()));
+
+        final DetailAstImpl returnTree;
+        final DetailAstImpl annotations = visit(ctx.anno);
+        if (annotations == null) {
+            returnTree = arrayDeclarator;
+        }
+        else {
+            returnTree = annotations;
+            addLastSibling(returnTree, arrayDeclarator);
+        }
+        return returnTree;
+    }
+
+    @Override
+    public DetailAstImpl visitPrimitiveType(CheckstyleJavaParser.PrimitiveTypeContext ctx) {
+        return create(ctx.start);
+    }
+
+    @Override
+    public DetailAstImpl visitTypeArguments(CheckstyleJavaParser.TypeArgumentsContext ctx) {
+        final DetailAstImpl typeArguments = createImaginary(TokenTypes.TYPE_ARGUMENTS);
+        typeArguments.addChild(create(TokenTypes.GENERIC_START, (Token) ctx.LT().getPayload()));
+        // Exclude '<' and '>'
+        processChildren(typeArguments, ctx.children.subList(1, ctx.children.size() - 1));
+        typeArguments.addChild(create(TokenTypes.GENERIC_END, (Token) ctx.GT().getPayload()));
+        return typeArguments;
+    }
+
+    @Override
+    public DetailAstImpl visitSuperSuffixDot(CheckstyleJavaParser.SuperSuffixDotContext ctx) {
+        final DetailAstImpl root;
+        if (ctx.LPAREN() == null) {
+            root = create(ctx.DOT());
+            root.addChild(visit(ctx.id()));
+        }
+        else {
+            root = create(TokenTypes.METHOD_CALL, (Token) ctx.LPAREN().getPayload());
+
+            final DetailAstImpl dot = create(ctx.DOT());
+            dot.addChild(visit(ctx.id()));
+            root.addChild(dot);
+
+            final DetailAstImpl expressionList = Optional.ofNullable(visit(ctx.expressionList()))
+                    .orElse(createImaginary(TokenTypes.ELIST));
+            root.addChild(expressionList);
+
+            root.addChild(create(ctx.RPAREN()));
+        }
+
+        return root;
+    }
+
+    @Override
+    public DetailAstImpl visitArguments(CheckstyleJavaParser.ArgumentsContext ctx) {
+        final DetailAstImpl lparen = create(ctx.LPAREN());
+
+        // We always add an 'ELIST' node
+        final DetailAstImpl expressionList = Optional.ofNullable(visit(ctx.expressionList()))
+                .orElse(createImaginary(TokenTypes.ELIST));
+        addLastSibling(lparen, expressionList);
+        addLastSibling(lparen, create(ctx.RPAREN()));
+        return lparen;
+    }
+
+    @Override
+    public DetailAstImpl visitPatternVariableDefinition(
+            CheckstyleJavaParser.PatternVariableDefinitionContext ctx) {
+        final DetailAstImpl type = visit(ctx.type);
+        final DetailAstImpl patternVariableDef = createImaginary(TokenTypes.PATTERN_VARIABLE_DEF);
+        patternVariableDef.addChild(createModifiers(ctx.mods));
+        patternVariableDef.addChild(type);
+        patternVariableDef.addChild(visit(ctx.id()));
+        return patternVariableDef;
+    }
+
+    @Override
+    public DetailAstImpl visitPermittedSubclassesAndInterfaces(
+            CheckstyleJavaParser.PermittedSubclassesAndInterfacesContext ctx) {
+        final DetailAstImpl literalPermits =
+                create(TokenTypes.PERMITS_CLAUSE, (Token) ctx.LITERAL_PERMITS().getPayload());
+        // 'LITERAL_PERMITS' is child[0]
+        processChildren(literalPermits, ctx.children.subList(1, ctx.children.size()));
+        return literalPermits;
+    }
+
+    @Override
+    public DetailAstImpl visitId(CheckstyleJavaParser.IdContext ctx) {
+        return create(TokenTypes.IDENT, ctx.start);
+    }
+
+    /**
+     * Builds the AST for a particular node, then returns a "flattened" tree
+     * of siblings. This method should be used in rule contexts such as
+     * {@code variableDeclarators}, where we have both terminals and non-terminals.
+     *
+     * @param ctx the ParserRuleContext to base tree on
+     * @return flattened DetailAstImpl
+     */
+    private DetailAstImpl flattenedTree(ParserRuleContext ctx) {
+        final DetailAstImpl dummyNode = new DetailAstImpl();
+        processChildren(dummyNode, ctx.children);
+        return dummyNode.getFirstChild();
+    }
+
+    /**
+     * Adds all the children from the given ParseTree or JavaParserContext
+     * list to the parent DetailAstImpl.
+     *
+     * @param parent the DetailAstImpl to add children to
+     * @param children the list of children to add
+     */
+    private void processChildren(DetailAstImpl parent, List<? extends ParseTree> children) {
+        children.forEach(child -> {
+            if (child instanceof TerminalNode) {
+                // Child is a token, create a new DetailAstImpl and add it to parent
+                parent.addChild(create((TerminalNode) child));
+            }
+            else {
+                // Child is another rule context; visit it, create token, and add to parent
+                parent.addChild(visit(child));
+            }
+        });
+    }
+
+    /**
+     * Create a DetailAstImpl from a given token and token type. This method
+     * should be used for imaginary nodes only, i.e. 'OBJBLOCK -> OBJBLOCK',
+     * where the text on the RHS matches the text on the LHS.
+     *
+     * @param tokenType  the token type of this DetailAstImpl
+     * @return new DetailAstImpl of given type
+     */
+    private static DetailAstImpl createImaginary(int tokenType) {
+        final DetailAstImpl detailAst = new DetailAstImpl();
+        detailAst.setType(tokenType);
+        detailAst.setText(TokenUtil.getTokenName(tokenType));
+        return detailAst;
+    }
+
+    /**
+     * Create a DetailAstImpl from a given token and token type. This method
+     * should be used for literal nodes only, i.e. 'PACKAGE_DEF -> package'.
+     *
+     * @param tokenType the token type of this DetailAstImpl
+     * @param startToken the first token that appears in this DetailAstImpl.
+     * @return new DetailAstImpl of given type
+     */
+    private DetailAstImpl create(int tokenType, Token startToken) {
+        final DetailAstImpl ast = create(startToken);
+        ast.setType(tokenType);
+        return ast;
+    }
+
+    /**
+     * Create a DetailAstImpl from a given token. This method should be
+     * used for terminal nodes, i.e. {@code LCURLY}, when we are building
+     * an AST for a specific token, regardless of position.
+     *
+     * @param token the token to build the DetailAstImpl from
+     * @return new DetailAstImpl of given type
+     */
+    private DetailAstImpl create(Token token) {
+        final int tokenIndex = token.getTokenIndex();
+        final List<Token> tokensToLeft =
+                tokens.getHiddenTokensToLeft(tokenIndex, JavaLexer.COMMENTS);
+        final List<Token> tokensToRight =
+                tokens.getHiddenTokensToRight(tokenIndex, JavaLexer.COMMENTS);
+
+        final DetailAstImpl detailAst = new DetailAstImpl();
+        detailAst.initialize(token);
+        if (tokensToLeft != null) {
+            detailAst.setHiddenBefore(tokensToLeft);
+        }
+        if (tokensToRight != null) {
+            detailAst.setHiddenAfter(tokensToRight);
+        }
+        return detailAst;
+    }
+
+    /**
+     * Create a DetailAstImpl from a given TerminalNode. This method should be
+     * used for terminal nodes, i.e. {@code @}.
+     *
+     * @param node the TerminalNode to build the DetailAstImpl from
+     * @return new DetailAstImpl of given type
+     */
+    private DetailAstImpl create(TerminalNode node) {
+        return create((Token) node.getPayload());
+    }
+
+    /**
+     * Creates a type declaration DetailAstImpl from a given rule context.
+     *
+     * @param ctx ParserRuleContext we are in
+     * @param type the type declaration to create
+     * @param modifierList respective modifiers
+     * @return type declaration DetailAstImpl
+     */
+    private DetailAstImpl createTypeDeclaration(ParserRuleContext ctx, int type,
+                                                List<? extends ParseTree> modifierList) {
+        final DetailAstImpl typeDeclaration = createImaginary(type);
+        typeDeclaration.addChild(createModifiers(modifierList));
+        processChildren(typeDeclaration, ctx.children);
+        return typeDeclaration;
+    }
+
+    /**
+     * Builds the modifiers AST.
+     *
+     * @param modifierList the list of modifier contexts
+     * @return "MODIFIERS" ast
+     */
+    private DetailAstImpl createModifiers(List<? extends ParseTree> modifierList) {
+        final DetailAstImpl mods = createImaginary(TokenTypes.MODIFIERS);
+        processChildren(mods, modifierList);
+        return mods;
+    }
+
+    /**
+     * Add new sibling to the end of existing siblings.
+     *
+     * @param self DetailAstImpl to add last sibling to
+     * @param sibling DetailAstImpl sibling to add
+     */
+    private static void addLastSibling(DetailAstImpl self, DetailAstImpl sibling) {
+        DetailAstImpl nextSibling = self;
+        if (nextSibling != null) {
+            while (nextSibling.getNextSibling() != null) {
+                nextSibling = nextSibling.getNextSibling();
+            }
+            nextSibling.setNextSibling(sibling);
+        }
+    }
+
+    @Override
+    public DetailAstImpl visit(ParseTree tree) {
+        DetailAstImpl ast = null;
+        if (tree != null) {
+            ast = tree.accept(this);
+        }
+        return ast;
+    }
+
+    /**
+     * Used to swap and organize DetailAstImpl subtrees.
+     */
+    private static final class DetailAstPair {
+
+        /** The root DetailAstImpl of this pair. */
+        private DetailAstImpl root;
+
+        /** The child (potentially with siblings) of this pair. */
+        private DetailAstImpl child;
+
+        /**
+         * Moves child reference to the last child.
+         */
+        private void advanceChildToEnd() {
+            while (child.getNextSibling() != null) {
+                child = child.getNextSibling();
+            }
+        }
+
+        private DetailAstImpl getRoot() {
+            return root;
+        }
+
+        /**
+         * This method is used to replace the {@code ^} (set as root node) ANTLR2
+         * operator.
+         *
+         * @param pair the DetailAstPair to use for swapping nodes
+         * @param ast the new root
+         */
+        private static void makeAstRoot(DetailAstPair pair, DetailAstImpl ast) {
+            ast.addChild(pair.root);
+            pair.child = pair.root;
+            pair.advanceChildToEnd();
+            pair.root = ast;
+        }
+
+        /**
+         * Adds a child (or new root) to the given DetailAstPair.
+         *
+         * @param pair the DetailAstPair to add child to
+         * @param ast the child to add
+         */
+        private static void addAstChild(DetailAstPair pair, DetailAstImpl ast) {
+            if (ast != null) {
+                if (pair.root == null) {
+                    pair.root = ast;
+                }
+                else {
+                    pair.child.setNextSibling(ast);
+                }
+                pair.child = ast;
+                pair.advanceChildToEnd();
+            }
+        }
+    }
+}
diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/JavaParser.java b/src/main/java/com/puppycrawl/tools/checkstyle/JavaParser.java
--- a/src/main/java/com/puppycrawl/tools/checkstyle/JavaParser.java
+++ b/src/main/java/com/puppycrawl/tools/checkstyle/JavaParser.java
@@ -21,26 +21,27 @@
 
 import java.io.File;
 import java.io.IOException;
-import java.io.Reader;
-import java.io.StringReader;
 import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.ListIterator;
 import java.util.Locale;
 
-import antlr.CommonASTWithHiddenTokens;
-import antlr.CommonHiddenStreamToken;
-import antlr.RecognitionException;
-import antlr.Token;
-import antlr.TokenStreamException;
-import antlr.TokenStreamHiddenTokenFilter;
-import antlr.TokenStreamSelector;
+import org.antlr.v4.runtime.BaseErrorListener;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonToken;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.RecognitionException;
+import org.antlr.v4.runtime.Recognizer;
+import org.antlr.v4.runtime.Token;
+
 import com.puppycrawl.tools.checkstyle.api.CheckstyleException;
 import com.puppycrawl.tools.checkstyle.api.DetailAST;
 import com.puppycrawl.tools.checkstyle.api.FileContents;
 import com.puppycrawl.tools.checkstyle.api.FileText;
 import com.puppycrawl.tools.checkstyle.api.TokenTypes;
-import com.puppycrawl.tools.checkstyle.grammar.GeneratedJavaLexer;
-import com.puppycrawl.tools.checkstyle.grammar.GeneratedJavaRecognizer;
-import com.puppycrawl.tools.checkstyle.grammar.GeneratedTextBlockLexer;
+import com.puppycrawl.tools.checkstyle.grammar.java.CheckstyleJavaParser;
+import com.puppycrawl.tools.checkstyle.grammar.java.JavaLexer;
 import com.puppycrawl.tools.checkstyle.utils.ParserUtil;
 
 /**
@@ -81,46 +82,29 @@ private JavaParser() {
     public static DetailAST parse(FileContents contents)
             throws CheckstyleException {
         final String fullText = contents.getText().getFullText().toString();
-        final Reader reader = new StringReader(fullText);
-        final GeneratedJavaLexer lexer = new GeneratedJavaLexer(reader);
+        final CharStream codePointCharStream = CharStreams.fromString(fullText);
+        final JavaLexer lexer = new JavaLexer(codePointCharStream, true);
         lexer.setCommentListener(contents);
+        lexer.removeErrorListeners();
 
-        final GeneratedTextBlockLexer textBlockLexer =
-                new GeneratedTextBlockLexer(lexer.getInputState());
-
-        final String tokenObjectClass = "antlr.CommonHiddenStreamToken";
-        lexer.setTokenObjectClass(tokenObjectClass);
-        textBlockLexer.setTokenObjectClass(tokenObjectClass);
-
-        final TokenStreamHiddenTokenFilter filter = new TokenStreamHiddenTokenFilter(lexer);
-        filter.hide(TokenTypes.SINGLE_LINE_COMMENT);
-        filter.hide(TokenTypes.BLOCK_COMMENT_BEGIN);
-
-        final TokenStreamSelector selector = new TokenStreamSelector();
-        lexer.selector = selector;
-        textBlockLexer.selector = selector;
-        selector.addInputStream(textBlockLexer, "textBlockLexer");
-        selector.select(filter);
+        final CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+        final CheckstyleJavaParser parser = new CheckstyleJavaParser(tokenStream);
+        parser.setErrorHandler(new CheckstyleParserErrorStrategy());
+        parser.removeErrorListeners();
+        parser.addErrorListener(new CheckstyleErrorListener());
 
-        final GeneratedJavaRecognizer parser = new GeneratedJavaRecognizer(selector) {
-            @Override
-            public void reportError(RecognitionException ex) {
-                throw new IllegalStateException(ex);
-            }
-        };
-        parser.setFilename(contents.getFileName());
-        parser.setASTNodeClass(DetailAstImpl.class.getName());
+        final CheckstyleJavaParser.CompilationUnitContext compilationUnit;
         try {
-            parser.compilationUnit();
+            compilationUnit = parser.compilationUnit();
         }
-        catch (RecognitionException | TokenStreamException | IllegalStateException ex) {
+        catch (IllegalStateException ex) {
             final String exceptionMsg = String.format(Locale.ROOT,
                 "%s occurred while parsing file %s.",
                 ex.getClass().getSimpleName(), contents.getFileName());
             throw new CheckstyleException(exceptionMsg, ex);
         }
 
-        return (DetailAST) parser.getAST();
+        return new JavaAstVisitor(tokenStream).visit(compilationUnit);
     }
 
     /**
@@ -173,21 +157,24 @@ public static DetailAST appendHiddenCommentNodes(DetailAST root) {
         while (curNode != null) {
             lastNode = curNode;
 
-            CommonHiddenStreamToken tokenBefore = ((CommonASTWithHiddenTokens) curNode)
-                    .getHiddenBefore();
-            DetailAST currentSibling = curNode;
-            while (tokenBefore != null) {
-                final DetailAST newCommentNode =
-                         createCommentAstFromToken(tokenBefore);
+            if (((DetailAstImpl) curNode).getHiddenBefore() != null) {
+                DetailAST currentSibling = curNode;
 
-                ((DetailAstImpl) currentSibling).addPreviousSibling(newCommentNode);
+                final List<Token> commentsList = ((DetailAstImpl) curNode).getHiddenBefore();
+                final ListIterator<Token> reverseCommentsIterator =
+                        commentsList.listIterator(commentsList.size());
 
-                if (currentSibling == result) {
-                    result = newCommentNode;
-                }
+                while (reverseCommentsIterator.hasPrevious()) {
+                    final DetailAST newCommentNode =
+                            createCommentAstFromToken((CommonToken)
+                                    reverseCommentsIterator.previous());
+                    ((DetailAstImpl) currentSibling).addPreviousSibling(newCommentNode);
 
-                currentSibling = newCommentNode;
-                tokenBefore = tokenBefore.getHiddenBefore();
+                    if (currentSibling == result) {
+                        result = newCommentNode;
+                    }
+                    currentSibling = newCommentNode;
+                }
             }
 
             DetailAST toVisit = curNode.getFirstChild();
@@ -197,18 +184,15 @@ public static DetailAST appendHiddenCommentNodes(DetailAST root) {
             }
             curNode = toVisit;
         }
-        if (lastNode != null) {
-            CommonHiddenStreamToken tokenAfter = ((CommonASTWithHiddenTokens) lastNode)
-                    .getHiddenAfter();
+        if (lastNode != null && ((DetailAstImpl) lastNode).getHiddenAfter() != null) {
             DetailAST currentSibling = lastNode;
-            while (tokenAfter != null) {
+            for (Token token: ((DetailAstImpl) lastNode).getHiddenAfter()) {
                 final DetailAST newCommentNode =
-                        createCommentAstFromToken(tokenAfter);
+                        createCommentAstFromToken((CommonToken) token);
 
                 ((DetailAstImpl) currentSibling).addNextSibling(newCommentNode);
 
                 currentSibling = newCommentNode;
-                tokenAfter = tokenAfter.getHiddenAfter();
             }
         }
         return result;
@@ -221,7 +205,7 @@ public static DetailAST appendHiddenCommentNodes(DetailAST root) {
      * @param token to create the AST
      * @return DetailAST of comment node
      */
-    private static DetailAST createCommentAstFromToken(Token token) {
+    private static DetailAST createCommentAstFromToken(CommonToken token) {
         final DetailAST commentAst;
         if (token.getType() == TokenTypes.SINGLE_LINE_COMMENT) {
             commentAst = createSlCommentNode(token);
@@ -238,21 +222,19 @@ private static DetailAST createCommentAstFromToken(Token token) {
      * @param token to create the AST
      * @return DetailAST with SINGLE_LINE_COMMENT type
      */
-    private static DetailAST createSlCommentNode(Token token) {
+    private static DetailAST createSlCommentNode(CommonToken token) {
         final DetailAstImpl slComment = new DetailAstImpl();
         slComment.setType(TokenTypes.SINGLE_LINE_COMMENT);
         slComment.setText("//");
 
-        // column counting begins from 0
-        slComment.setColumnNo(token.getColumn() - 1);
+        slComment.setColumnNo(token.getCharPositionInLine());
         slComment.setLineNo(token.getLine());
 
         final DetailAstImpl slCommentContent = new DetailAstImpl();
         slCommentContent.setType(TokenTypes.COMMENT_CONTENT);
 
-        // column counting begins from 0
         // plus length of '//'
-        slCommentContent.setColumnNo(token.getColumn() - 1 + 2);
+        slCommentContent.setColumnNo(token.getCharPositionInLine() + 2);
         slCommentContent.setLineNo(token.getLine());
         slCommentContent.setText(token.getText());
 
@@ -260,4 +242,17 @@ private static DetailAST createSlCommentNode(Token token) {
         return slComment;
     }
 
+    /**
+     * Custom error listener to provide detailed exception message.
+     */
+    private static class CheckstyleErrorListener extends BaseErrorListener {
+
+        @Override
+        public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol,
+                                int line, int charPositionInLine,
+                                String msg, RecognitionException ex) {
+            final String message = line + ":" + charPositionInLine + ": " + msg;
+            throw new IllegalStateException(message, ex);
+        }
+    }
 }
diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/JavadocDetailNodeParser.java b/src/main/java/com/puppycrawl/tools/checkstyle/JavadocDetailNodeParser.java
--- a/src/main/java/com/puppycrawl/tools/checkstyle/JavadocDetailNodeParser.java
+++ b/src/main/java/com/puppycrawl/tools/checkstyle/JavadocDetailNodeParser.java
@@ -23,16 +23,13 @@
 import java.util.Deque;
 import java.util.List;
 
-import org.antlr.v4.runtime.BailErrorStrategy;
 import org.antlr.v4.runtime.BaseErrorListener;
 import org.antlr.v4.runtime.BufferedTokenStream;
 import org.antlr.v4.runtime.CharStreams;
 import org.antlr.v4.runtime.CommonToken;
 import org.antlr.v4.runtime.CommonTokenStream;
 import org.antlr.v4.runtime.FailedPredicateException;
-import org.antlr.v4.runtime.InputMismatchException;
 import org.antlr.v4.runtime.NoViableAltException;
-import org.antlr.v4.runtime.Parser;
 import org.antlr.v4.runtime.ParserRuleContext;
 import org.antlr.v4.runtime.RecognitionException;
 import org.antlr.v4.runtime.Recognizer;
@@ -180,7 +177,7 @@ private static JavadocParser createJavadocParser(String blockComment,
 
         // JavadocParserErrorStrategy stops parsing on first parse error encountered unlike the
         // DefaultErrorStrategy used by ANTLR which rather attempts error recovery.
-        parser.setErrorHandler(new JavadocParserErrorStrategy());
+        parser.setErrorHandler(new CheckstyleParserErrorStrategy());
 
         return parser;
     }
@@ -779,29 +776,4 @@ public Object[] getMessageArguments() {
         }
 
     }
-
-    /**
-     * The DefaultErrorStrategy used by ANTLR attempts to recover from parse errors
-     * which might result in a performance overhead. Also, a parse error indicate
-     * that javadoc doesn't follow checkstyle Javadoc grammar and the user should be made aware
-     * of it.
-     * <a href="https://www.antlr.org/api/Java/org/antlr/v4/runtime/BailErrorStrategy.html">
-     * BailErrorStrategy</a> is used to make ANTLR generated parser bail out on the first error
-     * in parser and not attempt any recovery methods but it doesn't report error to the
-     * listeners. This class is to ensure proper error reporting.
-     *
-     * @see DescriptiveErrorListener
-     * @see <a href="https://www.antlr.org/api/Java/org/antlr/v4/runtime/ANTLRErrorStrategy.html">
-     *     ANTLRErrorStrategy</a>
-     */
-    private static class JavadocParserErrorStrategy extends BailErrorStrategy {
-
-        @Override
-        public Token recoverInline(Parser recognizer) {
-            reportError(recognizer, new InputMismatchException(recognizer));
-            return super.recoverInline(recognizer);
-        }
-
-    }
-
 }
diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/api/TokenTypes.java b/src/main/java/com/puppycrawl/tools/checkstyle/api/TokenTypes.java
--- a/src/main/java/com/puppycrawl/tools/checkstyle/api/TokenTypes.java
+++ b/src/main/java/com/puppycrawl/tools/checkstyle/api/TokenTypes.java
@@ -19,7 +19,9 @@
 
 package com.puppycrawl.tools.checkstyle.api;
 
-import com.puppycrawl.tools.checkstyle.grammar.GeneratedJavaTokenTypes;
+import org.antlr.v4.runtime.Recognizer;
+
+import com.puppycrawl.tools.checkstyle.grammar.java.JavaLexer;
 
 /**
  * Contains the constants for all the tokens contained in the Abstract
@@ -43,7 +45,7 @@ public final class TokenTypes {
      * @see #CLASS_DEF
      * @see #INTERFACE_DEF
      **/
-    public static final int EOF = GeneratedJavaTokenTypes.EOF;
+    public static final int EOF = Recognizer.EOF;
     /**
      * Modifiers for type, method, and field declarations.  The
      * modifiers element is always present even though it may have no
@@ -80,7 +82,7 @@ public final class TokenTypes {
      * @see #ANNOTATION
      * @see #LITERAL_DEFAULT
      **/
-    public static final int MODIFIERS = GeneratedJavaTokenTypes.MODIFIERS;
+    public static final int MODIFIERS = JavaLexer.MODIFIERS;
 
     /**
      * An object block.  These are children of class, interface, enum,
@@ -116,7 +118,7 @@ public final class TokenTypes {
      * @see #ENUM_CONSTANT_DEF
      * @see #ANNOTATION_DEF
      **/
-    public static final int OBJBLOCK = GeneratedJavaTokenTypes.OBJBLOCK;
+    public static final int OBJBLOCK = JavaLexer.OBJBLOCK;
     /**
      * A list of statements.
      *
@@ -158,7 +160,7 @@ public final class TokenTypes {
      * @see #LITERAL_ELSE
      * @see #CASE_GROUP
      **/
-    public static final int SLIST = GeneratedJavaTokenTypes.SLIST;
+    public static final int SLIST = JavaLexer.SLIST;
     /**
      * A constructor declaration.
      *
@@ -211,7 +213,7 @@ public final class TokenTypes {
      * @see #OBJBLOCK
      * @see #CLASS_DEF
      **/
-    public static final int CTOR_DEF = GeneratedJavaTokenTypes.CTOR_DEF;
+    public static final int CTOR_DEF = JavaLexer.CTOR_DEF;
     /**
      * A method declaration.  The children are modifiers, type parameters,
      * return type, method name, parameter list, an optional throws list, and
@@ -267,7 +269,7 @@ public final class TokenTypes {
      * @see #SLIST
      * @see #OBJBLOCK
      **/
-    public static final int METHOD_DEF = GeneratedJavaTokenTypes.METHOD_DEF;
+    public static final int METHOD_DEF = JavaLexer.METHOD_DEF;
     /**
      * A field or local variable declaration.  The children are
      * modifiers, type, the identifier name, and an optional
@@ -297,7 +299,7 @@ public final class TokenTypes {
      * @see #ASSIGN
      **/
     public static final int VARIABLE_DEF =
-        GeneratedJavaTokenTypes.VARIABLE_DEF;
+        JavaLexer.VARIABLE_DEF;
 
     /**
      * An instance initializer.  Zero or more instance initializers
@@ -311,7 +313,7 @@ public final class TokenTypes {
      * @see #OBJBLOCK
      **/
     public static final int INSTANCE_INIT =
-        GeneratedJavaTokenTypes.INSTANCE_INIT;
+        JavaLexer.INSTANCE_INIT;
 
     /**
      * A static initialization block.  Zero or more static
@@ -344,7 +346,7 @@ public final class TokenTypes {
      * @see #OBJBLOCK
      **/
     public static final int STATIC_INIT =
-        GeneratedJavaTokenTypes.STATIC_INIT;
+        JavaLexer.STATIC_INIT;
 
     /**
      * A type.  This is either a return type of a method or a type of
@@ -385,7 +387,7 @@ public final class TokenTypes {
      * @see #ARRAY_DECLARATOR
      * @see #TYPE_ARGUMENTS
      **/
-    public static final int TYPE = GeneratedJavaTokenTypes.TYPE;
+    public static final int TYPE = JavaLexer.TYPE;
     /**
      * A class declaration.
      *
@@ -416,7 +418,7 @@ public final class TokenTypes {
      * @see #OBJBLOCK
      * @see #LITERAL_NEW
      **/
-    public static final int CLASS_DEF = GeneratedJavaTokenTypes.CLASS_DEF;
+    public static final int CLASS_DEF = JavaLexer.CLASS_DEF;
     /**
      * An interface declaration.
      *
@@ -450,7 +452,7 @@ public final class TokenTypes {
      * @see #OBJBLOCK
      **/
     public static final int INTERFACE_DEF =
-        GeneratedJavaTokenTypes.INTERFACE_DEF;
+        JavaLexer.INTERFACE_DEF;
 
     /**
      * The package declaration.  This is optional, but if it is
@@ -491,7 +493,7 @@ public final class TokenTypes {
      * @see #ANNOTATIONS
      * @see FullIdent
      **/
-    public static final int PACKAGE_DEF = GeneratedJavaTokenTypes.PACKAGE_DEF;
+    public static final int PACKAGE_DEF = JavaLexer.PACKAGE_DEF;
     /**
      * An array declaration.
      *
@@ -529,7 +531,7 @@ public final class TokenTypes {
      * @see #ARRAY_INIT
      **/
     public static final int ARRAY_DECLARATOR =
-        GeneratedJavaTokenTypes.ARRAY_DECLARATOR;
+        JavaLexer.ARRAY_DECLARATOR;
 
     /**
      * An extends clause.  This appear as part of class and interface
@@ -563,7 +565,7 @@ public final class TokenTypes {
      * @see FullIdent
      **/
     public static final int EXTENDS_CLAUSE =
-        GeneratedJavaTokenTypes.EXTENDS_CLAUSE;
+        JavaLexer.EXTENDS_CLAUSE;
 
     /**
      * An implements clause.  This always appears in a class or enum
@@ -598,7 +600,7 @@ public final class TokenTypes {
      * @see #ENUM_DEF
      **/
     public static final int IMPLEMENTS_CLAUSE =
-        GeneratedJavaTokenTypes.IMPLEMENTS_CLAUSE;
+        JavaLexer.IMPLEMENTS_CLAUSE;
 
     /**
      * A list of parameters to a method or constructor.  The children
@@ -634,7 +636,7 @@ public final class TokenTypes {
      * @see #METHOD_DEF
      * @see #CTOR_DEF
      **/
-    public static final int PARAMETERS = GeneratedJavaTokenTypes.PARAMETERS;
+    public static final int PARAMETERS = JavaLexer.PARAMETERS;
     /**
      * A parameter declaration. The last parameter in a list of parameters may
      * be variable length (indicated by the ELLIPSIS child node immediately
@@ -676,7 +678,7 @@ public final class TokenTypes {
      * @see #ELLIPSIS
      **/
     public static final int PARAMETER_DEF =
-        GeneratedJavaTokenTypes.PARAMETER_DEF;
+        JavaLexer.PARAMETER_DEF;
 
     /**
      * A labeled statement.
@@ -725,7 +727,7 @@ public final class TokenTypes {
      * @see #SLIST
      **/
     public static final int LABELED_STAT =
-        GeneratedJavaTokenTypes.LABELED_STAT;
+        JavaLexer.LABELED_STAT;
 
     /**
      * A type-cast.
@@ -756,7 +758,7 @@ public final class TokenTypes {
      * @see #TYPE_ARGUMENTS
      * @see #RPAREN
      **/
-    public static final int TYPECAST = GeneratedJavaTokenTypes.TYPECAST;
+    public static final int TYPECAST = JavaLexer.TYPECAST;
     /**
      * The array index operator.
      *
@@ -779,7 +781,7 @@ public final class TokenTypes {
      *
      * @see #EXPR
      **/
-    public static final int INDEX_OP = GeneratedJavaTokenTypes.INDEX_OP;
+    public static final int INDEX_OP = JavaLexer.INDEX_OP;
     /**
      * The {@code ++} (postfix increment) operator.
      *
@@ -801,7 +803,7 @@ public final class TokenTypes {
      * @see #EXPR
      * @see #INC
      **/
-    public static final int POST_INC = GeneratedJavaTokenTypes.POST_INC;
+    public static final int POST_INC = JavaLexer.POST_INC;
     /**
      * The {@code --} (postfix decrement) operator.
      *
@@ -823,7 +825,7 @@ public final class TokenTypes {
      * @see #EXPR
      * @see #DEC
      **/
-    public static final int POST_DEC = GeneratedJavaTokenTypes.POST_DEC;
+    public static final int POST_DEC = JavaLexer.POST_DEC;
     /**
      * A method call. A method call may have type arguments however these
      * are attached to the appropriate node in the qualified method name.
@@ -855,7 +857,7 @@ public final class TokenTypes {
      * @see #RPAREN
      * @see FullIdent
      **/
-    public static final int METHOD_CALL = GeneratedJavaTokenTypes.METHOD_CALL;
+    public static final int METHOD_CALL = JavaLexer.METHOD_CALL;
 
     /**
      * A reference to a method or constructor without arguments. Part of Java 8 syntax.
@@ -890,7 +892,7 @@ public final class TokenTypes {
      * @see #IDENT
      * @see #DOUBLE_COLON
      */
-    public static final int METHOD_REF = GeneratedJavaTokenTypes.METHOD_REF;
+    public static final int METHOD_REF = JavaLexer.METHOD_REF;
     /**
      * An expression.  Operators with lower precedence appear at a
      * higher level in the tree than operators with higher precedence.
@@ -936,7 +938,7 @@ public final class TokenTypes {
      * @see #LPAREN
      * @see #RPAREN
      **/
-    public static final int EXPR = GeneratedJavaTokenTypes.EXPR;
+    public static final int EXPR = JavaLexer.EXPR;
     /**
      * An array initialization.  This may occur as part of an array
      * declaration or inline with {@code new}.
@@ -1009,7 +1011,7 @@ public final class TokenTypes {
      * @see #LITERAL_NEW
      * @see #COMMA
      **/
-    public static final int ARRAY_INIT = GeneratedJavaTokenTypes.ARRAY_INIT;
+    public static final int ARRAY_INIT = JavaLexer.ARRAY_INIT;
     /**
      * An import declaration.  Import declarations are option, but
      * must appear after the package declaration and before the first type
@@ -1042,7 +1044,7 @@ public final class TokenTypes {
      * @see #SEMI
      * @see FullIdent
      **/
-    public static final int IMPORT = GeneratedJavaTokenTypes.IMPORT;
+    public static final int IMPORT = JavaLexer.IMPORT;
     /**
      * The {@code -} (unary minus) operator.
      * <p>For example:</p>
@@ -1064,7 +1066,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.15.4</a>
      * @see #EXPR
      **/
-    public static final int UNARY_MINUS = GeneratedJavaTokenTypes.UNARY_MINUS;
+    public static final int UNARY_MINUS = JavaLexer.UNARY_MINUS;
     /**
      * The {@code +} (unary plus) operator.
      * <p>For example:</p>
@@ -1086,7 +1088,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.15.3</a>
      * @see #EXPR
      **/
-    public static final int UNARY_PLUS = GeneratedJavaTokenTypes.UNARY_PLUS;
+    public static final int UNARY_PLUS = JavaLexer.UNARY_PLUS;
     /**
      * A group of case clauses.  Case clauses with no associated
      * statements are grouped together into a case group.  The last
@@ -1131,7 +1133,7 @@ public final class TokenTypes {
      * @see #LITERAL_SWITCH
      * @see #LITERAL_YIELD
      **/
-    public static final int CASE_GROUP = GeneratedJavaTokenTypes.CASE_GROUP;
+    public static final int CASE_GROUP = JavaLexer.CASE_GROUP;
     /**
      * An expression list.  The children are a comma separated list of
      * expressions.
@@ -1144,7 +1146,7 @@ public final class TokenTypes {
      * @see #CTOR_CALL
      * @see #SUPER_CTOR_CALL
      **/
-    public static final int ELIST = GeneratedJavaTokenTypes.ELIST;
+    public static final int ELIST = JavaLexer.ELIST;
     /**
      * A for loop initializer.  This is a child of
      * {@code LITERAL_FOR}.  The children of this element may be
@@ -1191,7 +1193,7 @@ public final class TokenTypes {
      * @see #ELIST
      * @see #LITERAL_FOR
      **/
-    public static final int FOR_INIT = GeneratedJavaTokenTypes.FOR_INIT;
+    public static final int FOR_INIT = JavaLexer.FOR_INIT;
     /**
      * A for loop condition.  This is a child of
      * {@code LITERAL_FOR}.  The child of this element is an
@@ -1237,7 +1239,7 @@ public final class TokenTypes {
      * @see #LITERAL_FOR
      **/
     public static final int FOR_CONDITION =
-        GeneratedJavaTokenTypes.FOR_CONDITION;
+        JavaLexer.FOR_CONDITION;
 
     /**
      * A for loop iterator.  This is a child of
@@ -1284,7 +1286,7 @@ public final class TokenTypes {
      * @see #LITERAL_FOR
      **/
     public static final int FOR_ITERATOR =
-        GeneratedJavaTokenTypes.FOR_ITERATOR;
+        JavaLexer.FOR_ITERATOR;
 
     /**
      * The empty statement.  This goes in place of an
@@ -1297,7 +1299,7 @@ public final class TokenTypes {
      * @see #LITERAL_FOR
      * @see #LITERAL_WHILE
      **/
-    public static final int EMPTY_STAT = GeneratedJavaTokenTypes.EMPTY_STAT;
+    public static final int EMPTY_STAT = JavaLexer.EMPTY_STAT;
     /**
      * The {@code final} keyword.
      *
@@ -1322,7 +1324,7 @@ public final class TokenTypes {
      *
      * @see #MODIFIERS
      **/
-    public static final int FINAL = GeneratedJavaTokenTypes.FINAL;
+    public static final int FINAL = JavaLexer.FINAL;
     /**
      * The {@code abstract} keyword.
      *
@@ -1347,7 +1349,7 @@ public final class TokenTypes {
      *
      * @see #MODIFIERS
      **/
-    public static final int ABSTRACT = GeneratedJavaTokenTypes.ABSTRACT;
+    public static final int ABSTRACT = JavaLexer.ABSTRACT;
     /**
      * The {@code strictfp} keyword.
      *
@@ -1369,7 +1371,7 @@ public final class TokenTypes {
      *
      * @see #MODIFIERS
      **/
-    public static final int STRICTFP = GeneratedJavaTokenTypes.STRICTFP;
+    public static final int STRICTFP = JavaLexer.STRICTFP;
     /**
      * A super constructor call.
      *
@@ -1379,7 +1381,7 @@ public final class TokenTypes {
      * @see #CTOR_CALL
      **/
     public static final int SUPER_CTOR_CALL =
-        GeneratedJavaTokenTypes.SUPER_CTOR_CALL;
+        JavaLexer.SUPER_CTOR_CALL;
 
     /**
      * A constructor call.
@@ -1407,7 +1409,7 @@ public final class TokenTypes {
      * @see #SEMI
      * @see #SUPER_CTOR_CALL
      **/
-    public static final int CTOR_CALL = GeneratedJavaTokenTypes.CTOR_CALL;
+    public static final int CTOR_CALL = JavaLexer.CTOR_CALL;
 
     /**
      * The statement terminator ({@code ;}).  Depending on the
@@ -1436,7 +1438,7 @@ public final class TokenTypes {
      * @see #ARRAY_INIT
      * @see #LITERAL_FOR
      **/
-    public static final int SEMI = GeneratedJavaTokenTypes.SEMI;
+    public static final int SEMI = JavaLexer.SEMI;
 
     /**
      * The {@code ]} symbol.
@@ -1460,13 +1462,13 @@ public final class TokenTypes {
      * @see #INDEX_OP
      * @see #ARRAY_DECLARATOR
      **/
-    public static final int RBRACK = GeneratedJavaTokenTypes.RBRACK;
+    public static final int RBRACK = JavaLexer.RBRACK;
     /**
      * The {@code void} keyword.
      *
      * <p>For example:</p>
      * <pre>
-     * {@code void literal_void(){}}
+     * {@code void LITERAL_VOID(){}}
      * </pre>
      * <p>'void' parses as:</p>
      * <pre>
@@ -1474,13 +1476,13 @@ public final class TokenTypes {
      *  |--MODIFIERS -&gt; MODIFIERS
      *  |--TYPE -&gt; TYPE
      *  |   `--LITERAL_VOID -&gt; void
-     *  |--IDENT -&gt; literal_void
+     *  |--IDENT -&gt; LITERAL_VOID
      * </pre>
      *
      * @see #TYPE
      **/
     public static final int LITERAL_VOID =
-        GeneratedJavaTokenTypes.LITERAL_void;
+        JavaLexer.LITERAL_VOID;
 
     /**
      * The {@code boolean} keyword.
@@ -1488,7 +1490,7 @@ public final class TokenTypes {
      * @see #TYPE
      **/
     public static final int LITERAL_BOOLEAN =
-        GeneratedJavaTokenTypes.LITERAL_boolean;
+        JavaLexer.LITERAL_BOOLEAN;
 
     /**
      * The {@code byte} keyword.
@@ -1511,7 +1513,7 @@ public final class TokenTypes {
      * @see #TYPE
      **/
     public static final int LITERAL_BYTE =
-        GeneratedJavaTokenTypes.LITERAL_byte;
+        JavaLexer.LITERAL_BYTE;
 
     /**
      * The {@code char} keyword.
@@ -1536,7 +1538,7 @@ public final class TokenTypes {
      * @see #TYPE
      **/
     public static final int LITERAL_CHAR =
-        GeneratedJavaTokenTypes.LITERAL_char;
+        JavaLexer.LITERAL_CHAR;
 
     /**
      * The {@code short} keyword.
@@ -1559,7 +1561,7 @@ public final class TokenTypes {
      * @see #TYPE
      **/
     public static final int LITERAL_SHORT =
-        GeneratedJavaTokenTypes.LITERAL_short;
+        JavaLexer.LITERAL_SHORT;
 
     /**
      * The {@code int} keyword.
@@ -1581,7 +1583,7 @@ public final class TokenTypes {
      *
      * @see #TYPE
      **/
-    public static final int LITERAL_INT = GeneratedJavaTokenTypes.LITERAL_int;
+    public static final int LITERAL_INT = JavaLexer.LITERAL_INT;
     /**
      * The {@code float} keyword.
      *
@@ -1603,7 +1605,7 @@ public final class TokenTypes {
      * @see #TYPE
      **/
     public static final int LITERAL_FLOAT =
-        GeneratedJavaTokenTypes.LITERAL_float;
+        JavaLexer.LITERAL_FLOAT;
 
     /**
      * The {@code long} keyword.
@@ -1626,7 +1628,7 @@ public final class TokenTypes {
      * @see #TYPE
      **/
     public static final int LITERAL_LONG =
-        GeneratedJavaTokenTypes.LITERAL_long;
+        JavaLexer.LITERAL_LONG;
 
     /**
      * The {@code double} keyword.
@@ -1649,13 +1651,13 @@ public final class TokenTypes {
      * @see #TYPE
      **/
     public static final int LITERAL_DOUBLE =
-        GeneratedJavaTokenTypes.LITERAL_double;
+        JavaLexer.LITERAL_DOUBLE;
 
     /**
      * An identifier.  These can be names of types, subpackages,
      * fields, methods, parameters, and local variables.
      **/
-    public static final int IDENT = GeneratedJavaTokenTypes.IDENT;
+    public static final int IDENT = JavaLexer.IDENT;
     /**
      * The <code>&#46;</code> (dot) operator.
      *
@@ -1676,7 +1678,7 @@ public final class TokenTypes {
      * @see FullIdent
      * @noinspection HtmlTagCanBeJavadocTag
      **/
-    public static final int DOT = GeneratedJavaTokenTypes.DOT;
+    public static final int DOT = JavaLexer.DOT;
     /**
      * The {@code *} (multiplication or wildcard) operator.
      *
@@ -1704,7 +1706,7 @@ public final class TokenTypes {
      * @see #EXPR
      * @see #IMPORT
      **/
-    public static final int STAR = GeneratedJavaTokenTypes.STAR;
+    public static final int STAR = JavaLexer.STAR;
     /**
      * The {@code private} keyword.
      *
@@ -1726,7 +1728,7 @@ public final class TokenTypes {
      * @see #MODIFIERS
      **/
     public static final int LITERAL_PRIVATE =
-        GeneratedJavaTokenTypes.LITERAL_private;
+        JavaLexer.LITERAL_PRIVATE;
 
     /**
      * The {@code public} keyword.
@@ -1749,7 +1751,7 @@ public final class TokenTypes {
      * @see #MODIFIERS
      **/
     public static final int LITERAL_PUBLIC =
-        GeneratedJavaTokenTypes.LITERAL_public;
+        JavaLexer.LITERAL_PUBLIC;
 
     /**
      * The {@code protected} keyword.
@@ -1772,7 +1774,7 @@ public final class TokenTypes {
      * @see #MODIFIERS
      **/
     public static final int LITERAL_PROTECTED =
-        GeneratedJavaTokenTypes.LITERAL_protected;
+        JavaLexer.LITERAL_PROTECTED;
 
     /**
      * The {@code static} keyword.
@@ -1796,7 +1798,7 @@ public final class TokenTypes {
      * @see #MODIFIERS
      **/
     public static final int LITERAL_STATIC =
-        GeneratedJavaTokenTypes.LITERAL_static;
+        JavaLexer.LITERAL_STATIC;
 
     /**
      * The {@code transient} keyword.
@@ -1819,7 +1821,7 @@ public final class TokenTypes {
      * @see #MODIFIERS
      **/
     public static final int LITERAL_TRANSIENT =
-        GeneratedJavaTokenTypes.LITERAL_transient;
+        JavaLexer.LITERAL_TRANSIENT;
 
     /**
      * The {@code native} keyword.
@@ -1827,7 +1829,7 @@ public final class TokenTypes {
      * @see #MODIFIERS
      **/
     public static final int LITERAL_NATIVE =
-        GeneratedJavaTokenTypes.LITERAL_native;
+        JavaLexer.LITERAL_NATIVE;
 
     /**
      * The {@code synchronized} keyword.  This may be used as a
@@ -1868,7 +1870,7 @@ public final class TokenTypes {
      * @see #RCURLY
      **/
     public static final int LITERAL_SYNCHRONIZED =
-        GeneratedJavaTokenTypes.LITERAL_synchronized;
+        JavaLexer.LITERAL_SYNCHRONIZED;
 
     /**
      * The {@code volatile} keyword. This may be used as a
@@ -1892,7 +1894,7 @@ public final class TokenTypes {
      * @see #MODIFIERS
      **/
     public static final int LITERAL_VOLATILE =
-        GeneratedJavaTokenTypes.LITERAL_volatile;
+        JavaLexer.LITERAL_VOLATILE;
 
     /**
      * The {@code class} keyword.  This element appears both
@@ -1932,7 +1934,7 @@ public final class TokenTypes {
      * @see FullIdent
      **/
     public static final int LITERAL_CLASS =
-        GeneratedJavaTokenTypes.LITERAL_class;
+        JavaLexer.LITERAL_CLASS;
 
     /**
      * The {@code interface} keyword. This token appears in
@@ -1962,7 +1964,7 @@ public final class TokenTypes {
      * @see #INTERFACE_DEF
      **/
     public static final int LITERAL_INTERFACE =
-        GeneratedJavaTokenTypes.LITERAL_interface;
+        JavaLexer.LITERAL_INTERFACE;
 
     /**
      * A left curly brace (<code>{</code>).
@@ -1995,7 +1997,7 @@ public final class TokenTypes {
      * @see #ARRAY_INIT
      * @see #SLIST
      **/
-    public static final int LCURLY = GeneratedJavaTokenTypes.LCURLY;
+    public static final int LCURLY = JavaLexer.LCURLY;
     /**
      * A right curly brace (<code>}</code>).
      *
@@ -2023,7 +2025,7 @@ public final class TokenTypes {
      * @see #ARRAY_INIT
      * @see #SLIST
      **/
-    public static final int RCURLY = GeneratedJavaTokenTypes.RCURLY;
+    public static final int RCURLY = JavaLexer.RCURLY;
 
     /**
      * The {@code ,} (comma) operator.
@@ -2054,7 +2056,7 @@ public final class TokenTypes {
      * @see #LITERAL_THROWS
      * @see #IMPLEMENTS_CLAUSE
      **/
-    public static final int COMMA = GeneratedJavaTokenTypes.COMMA;
+    public static final int COMMA = JavaLexer.COMMA;
 
     /**
      * A left parenthesis ({@code (}).
@@ -2104,7 +2106,7 @@ public final class TokenTypes {
      * @see #LITERAL_SWITCH
      * @see #LITERAL_CATCH
      **/
-    public static final int LPAREN = GeneratedJavaTokenTypes.LPAREN;
+    public static final int LPAREN = JavaLexer.LPAREN;
     /**
      * A right parenthesis ({@code )}).
      *
@@ -2135,7 +2137,7 @@ public final class TokenTypes {
      * @see #LITERAL_SWITCH
      * @see #LITERAL_CATCH
      **/
-    public static final int RPAREN = GeneratedJavaTokenTypes.RPAREN;
+    public static final int RPAREN = JavaLexer.RPAREN;
     /**
      * The {@code this} keyword use to refer the current object.
      * This can also be used to call the constructor.
@@ -2176,7 +2178,7 @@ public final class TokenTypes {
      * @see #CTOR_CALL
      **/
     public static final int LITERAL_THIS =
-        GeneratedJavaTokenTypes.LITERAL_this;
+        JavaLexer.LITERAL_THIS;
 
     /**
      * The {@code super} keyword.
@@ -2201,7 +2203,7 @@ public final class TokenTypes {
      * @see #SUPER_CTOR_CALL
      **/
     public static final int LITERAL_SUPER =
-        GeneratedJavaTokenTypes.LITERAL_super;
+        JavaLexer.LITERAL_SUPER;
 
     /**
      * The {@code =} (assignment) operator.
@@ -2224,7 +2226,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.26.1</a>
      * @see #EXPR
      **/
-    public static final int ASSIGN = GeneratedJavaTokenTypes.ASSIGN;
+    public static final int ASSIGN = JavaLexer.ASSIGN;
     /**
      * The {@code throws} keyword.  The children are a number of
      * one or more identifiers separated by commas.
@@ -2263,7 +2265,7 @@ public final class TokenTypes {
      * @see FullIdent
      **/
     public static final int LITERAL_THROWS =
-        GeneratedJavaTokenTypes.LITERAL_throws;
+        JavaLexer.LITERAL_THROWS;
 
     /**
      * The {@code :} (colon) operator.  This will appear as part
@@ -2289,7 +2291,7 @@ public final class TokenTypes {
      * @see #LABELED_STAT
      * @see #CASE_GROUP
      **/
-    public static final int COLON = GeneratedJavaTokenTypes.COLON;
+    public static final int COLON = JavaLexer.COLON;
 
     /**
      * The {@code ::} (double colon) separator.
@@ -2298,7 +2300,7 @@ public final class TokenTypes {
      *
      * @see #METHOD_REF
      */
-    public static final int DOUBLE_COLON = GeneratedJavaTokenTypes.DOUBLE_COLON;
+    public static final int DOUBLE_COLON = JavaLexer.DOUBLE_COLON;
     /**
      * The {@code if} keyword.
      *
@@ -2344,7 +2346,7 @@ public final class TokenTypes {
      * @see #EMPTY_STAT
      * @see #LITERAL_ELSE
      **/
-    public static final int LITERAL_IF = GeneratedJavaTokenTypes.LITERAL_if;
+    public static final int LITERAL_IF = JavaLexer.LITERAL_IF;
     /**
      * The {@code for} keyword.  The children are {@code (},
      * an initializer, a condition, an iterator, a {@code )} and
@@ -2397,7 +2399,7 @@ public final class TokenTypes {
      * @see #EMPTY_STAT
      * @see #EXPR
      **/
-    public static final int LITERAL_FOR = GeneratedJavaTokenTypes.LITERAL_for;
+    public static final int LITERAL_FOR = JavaLexer.LITERAL_FOR;
     /**
      * The {@code while} keyword.
      *
@@ -2425,7 +2427,7 @@ public final class TokenTypes {
      * </pre>
      **/
     public static final int LITERAL_WHILE =
-        GeneratedJavaTokenTypes.LITERAL_while;
+        JavaLexer.LITERAL_WHILE;
 
     /**
      * The {@code do} keyword.  Note the the while token does not
@@ -2469,7 +2471,7 @@ public final class TokenTypes {
      * @see #RPAREN
      * @see #SEMI
      **/
-    public static final int LITERAL_DO = GeneratedJavaTokenTypes.LITERAL_do;
+    public static final int LITERAL_DO = JavaLexer.LITERAL_DO;
     /**
      * Literal {@code while} in do-while loop.
      *
@@ -2496,7 +2498,7 @@ public final class TokenTypes {
      *
      * @see #LITERAL_DO
      */
-    public static final int DO_WHILE = GeneratedJavaTokenTypes.DO_WHILE;
+    public static final int DO_WHILE = JavaLexer.DO_WHILE;
     /**
      * The {@code break} keyword.  The first child is an optional
      * identifier and the last child is a semicolon.
@@ -2506,7 +2508,7 @@ public final class TokenTypes {
      * @see #SLIST
      **/
     public static final int LITERAL_BREAK =
-        GeneratedJavaTokenTypes.LITERAL_break;
+        JavaLexer.LITERAL_BREAK;
 
     /**
      * The {@code continue} keyword.  The first child is an
@@ -2539,7 +2541,7 @@ public final class TokenTypes {
      * @see #SLIST
      **/
     public static final int LITERAL_CONTINUE =
-        GeneratedJavaTokenTypes.LITERAL_continue;
+        JavaLexer.LITERAL_CONTINUE;
 
     /**
      * The {@code return} keyword.  The first child is an
@@ -2583,7 +2585,7 @@ public final class TokenTypes {
      * @see #SLIST
      **/
     public static final int LITERAL_RETURN =
-        GeneratedJavaTokenTypes.LITERAL_return;
+        JavaLexer.LITERAL_RETURN;
 
     /**
      * The {@code switch} keyword.
@@ -2666,7 +2668,7 @@ public final class TokenTypes {
      * @see #SWITCH_RULE
      **/
     public static final int LITERAL_SWITCH =
-        GeneratedJavaTokenTypes.LITERAL_switch;
+        JavaLexer.LITERAL_SWITCH;
 
     /**
      * The {@code throw} keyword.  The first child is an
@@ -2679,7 +2681,7 @@ public final class TokenTypes {
      * @see #EXPR
      **/
     public static final int LITERAL_THROW =
-        GeneratedJavaTokenTypes.LITERAL_throw;
+        JavaLexer.LITERAL_THROW;
 
     /**
      * The {@code else} keyword.  This appears as a child of an
@@ -2713,7 +2715,7 @@ public final class TokenTypes {
      * @see #LITERAL_IF
      **/
     public static final int LITERAL_ELSE =
-        GeneratedJavaTokenTypes.LITERAL_else;
+        JavaLexer.LITERAL_ELSE;
 
     /**
      * The {@code case} keyword.  The first child is a constant
@@ -2766,7 +2768,7 @@ public final class TokenTypes {
      * @see #EXPR
      **/
     public static final int LITERAL_CASE =
-        GeneratedJavaTokenTypes.LITERAL_case;
+        JavaLexer.LITERAL_CASE;
 
     /**
      * The {@code default} keyword.  This element has no
@@ -2820,7 +2822,7 @@ public final class TokenTypes {
      * @see #SWITCH_RULE
      **/
     public static final int LITERAL_DEFAULT =
-        GeneratedJavaTokenTypes.LITERAL_default;
+        JavaLexer.LITERAL_DEFAULT;
 
     /**
      * The {@code try} keyword.  The children are a statement
@@ -2848,7 +2850,7 @@ public final class TokenTypes {
      * @see #LITERAL_CATCH
      * @see #LITERAL_FINALLY
      **/
-    public static final int LITERAL_TRY = GeneratedJavaTokenTypes.LITERAL_try;
+    public static final int LITERAL_TRY = JavaLexer.LITERAL_TRY;
 
     /**
      * The Java 7 try-with-resources construct.
@@ -2938,7 +2940,7 @@ public final class TokenTypes {
      * @see #LITERAL_TRY
      **/
     public static final int RESOURCE_SPECIFICATION =
-        GeneratedJavaTokenTypes.RESOURCE_SPECIFICATION;
+        JavaLexer.RESOURCE_SPECIFICATION;
 
     /**
      * A list of resources in the Java 7 try-with-resources construct.
@@ -2980,7 +2982,7 @@ public final class TokenTypes {
      * @see #RESOURCE_SPECIFICATION
      **/
     public static final int RESOURCES =
-        GeneratedJavaTokenTypes.RESOURCES;
+        JavaLexer.RESOURCES;
 
     /**
      * A resource in the Java 7 try-with-resources construct.
@@ -3030,7 +3032,7 @@ public final class TokenTypes {
      * @see #RESOURCE_SPECIFICATION
      **/
     public static final int RESOURCE =
-        GeneratedJavaTokenTypes.RESOURCE;
+        JavaLexer.RESOURCE;
 
     /**
      * The {@code catch} keyword.
@@ -3082,7 +3084,7 @@ public final class TokenTypes {
      * @see #LITERAL_TRY
      **/
     public static final int LITERAL_CATCH =
-        GeneratedJavaTokenTypes.LITERAL_catch;
+        JavaLexer.LITERAL_CATCH;
 
     /**
      * The {@code finally} keyword.
@@ -3105,7 +3107,7 @@ public final class TokenTypes {
      * @see #LITERAL_TRY
      **/
     public static final int LITERAL_FINALLY =
-        GeneratedJavaTokenTypes.LITERAL_finally;
+        JavaLexer.LITERAL_FINALLY;
 
     /**
      * The {@code +=} (addition assignment) operator.
@@ -3128,7 +3130,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.26.2</a>
      * @see #EXPR
      **/
-    public static final int PLUS_ASSIGN = GeneratedJavaTokenTypes.PLUS_ASSIGN;
+    public static final int PLUS_ASSIGN = JavaLexer.PLUS_ASSIGN;
     /**
      * The {@code -=} (subtraction assignment) operator.
      *
@@ -3151,7 +3153,7 @@ public final class TokenTypes {
      * @see #EXPR
      **/
     public static final int MINUS_ASSIGN =
-        GeneratedJavaTokenTypes.MINUS_ASSIGN;
+        JavaLexer.MINUS_ASSIGN;
 
     /**
      * The {@code *=} (multiplication assignment) operator.
@@ -3174,7 +3176,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.26.2</a>
      * @see #EXPR
      **/
-    public static final int STAR_ASSIGN = GeneratedJavaTokenTypes.STAR_ASSIGN;
+    public static final int STAR_ASSIGN = JavaLexer.STAR_ASSIGN;
     /**
      * The {@code /=} (division assignment) operator.
      *
@@ -3196,7 +3198,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.26.2</a>
      * @see #EXPR
      **/
-    public static final int DIV_ASSIGN = GeneratedJavaTokenTypes.DIV_ASSIGN;
+    public static final int DIV_ASSIGN = JavaLexer.DIV_ASSIGN;
     /**
      * The {@code %=} (remainder assignment) operator.
      * <p>For example:</p>
@@ -3215,7 +3217,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.26.2</a>
      * @see #EXPR
      **/
-    public static final int MOD_ASSIGN = GeneratedJavaTokenTypes.MOD_ASSIGN;
+    public static final int MOD_ASSIGN = JavaLexer.MOD_ASSIGN;
     /**
      * The {@code >>=} (signed right shift assignment)
      * operator.
@@ -3238,7 +3240,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.26.2</a>
      * @see #EXPR
      **/
-    public static final int SR_ASSIGN = GeneratedJavaTokenTypes.SR_ASSIGN;
+    public static final int SR_ASSIGN = JavaLexer.SR_ASSIGN;
     /**
      * The {@code >>>=} (unsigned right shift assignment)
      * operator.
@@ -3261,7 +3263,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.26.2</a>
      * @see #EXPR
      **/
-    public static final int BSR_ASSIGN = GeneratedJavaTokenTypes.BSR_ASSIGN;
+    public static final int BSR_ASSIGN = JavaLexer.BSR_ASSIGN;
     /**
      * The {@code <<=} (left shift assignment) operator.
      *
@@ -3270,7 +3272,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.26.2</a>
      * @see #EXPR
      **/
-    public static final int SL_ASSIGN = GeneratedJavaTokenTypes.SL_ASSIGN;
+    public static final int SL_ASSIGN = JavaLexer.SL_ASSIGN;
     /**
      * The {@code &=} (bitwise AND assignment) operator.
      *
@@ -3292,7 +3294,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.26.2</a>
      * @see #EXPR
      **/
-    public static final int BAND_ASSIGN = GeneratedJavaTokenTypes.BAND_ASSIGN;
+    public static final int BAND_ASSIGN = JavaLexer.BAND_ASSIGN;
     /**
      * The {@code ^=} (bitwise exclusive OR assignment) operator.
      *
@@ -3301,7 +3303,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.26.2</a>
      * @see #EXPR
      **/
-    public static final int BXOR_ASSIGN = GeneratedJavaTokenTypes.BXOR_ASSIGN;
+    public static final int BXOR_ASSIGN = JavaLexer.BXOR_ASSIGN;
     /**
      * The {@code |=} (bitwise OR assignment) operator.
      *
@@ -3323,7 +3325,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.26.2</a>
      * @see #EXPR
      **/
-    public static final int BOR_ASSIGN = GeneratedJavaTokenTypes.BOR_ASSIGN;
+    public static final int BOR_ASSIGN = JavaLexer.BOR_ASSIGN;
     /**
      * The <code>&#63;</code> (conditional) operator.  Technically,
      * the colon is also part of this operator, but it appears as a
@@ -3361,7 +3363,7 @@ public final class TokenTypes {
      * @see #COLON
      * @noinspection HtmlTagCanBeJavadocTag
      **/
-    public static final int QUESTION = GeneratedJavaTokenTypes.QUESTION;
+    public static final int QUESTION = JavaLexer.QUESTION;
     /**
      * The {@code ||} (conditional OR) operator.
      *
@@ -3390,7 +3392,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.24</a>
      * @see #EXPR
      **/
-    public static final int LOR = GeneratedJavaTokenTypes.LOR;
+    public static final int LOR = JavaLexer.LOR;
     /**
      * The {@code &&} (conditional AND) operator.
      *
@@ -3418,7 +3420,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.23</a>
      * @see #EXPR
      **/
-    public static final int LAND = GeneratedJavaTokenTypes.LAND;
+    public static final int LAND = JavaLexer.LAND;
     /**
      * The {@code |} (bitwise OR) operator.
      *
@@ -3442,7 +3444,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.22.1</a>
      * @see #EXPR
      **/
-    public static final int BOR = GeneratedJavaTokenTypes.BOR;
+    public static final int BOR = JavaLexer.BOR;
     /**
      * The {@code ^} (bitwise exclusive OR) operator.
      *
@@ -3451,7 +3453,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.22.1</a>
      * @see #EXPR
      **/
-    public static final int BXOR = GeneratedJavaTokenTypes.BXOR;
+    public static final int BXOR = JavaLexer.BXOR;
     /**
      * The {@code &} (bitwise AND) operator.
      *
@@ -3475,7 +3477,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.22.1</a>
      * @see #EXPR
      **/
-    public static final int BAND = GeneratedJavaTokenTypes.BAND;
+    public static final int BAND = JavaLexer.BAND;
     /**
      * The <code>&#33;=</code> (not equal) operator.
      *
@@ -3495,7 +3497,7 @@ public final class TokenTypes {
      * @see #EXPR
      * @noinspection HtmlTagCanBeJavadocTag
      **/
-    public static final int NOT_EQUAL = GeneratedJavaTokenTypes.NOT_EQUAL;
+    public static final int NOT_EQUAL = JavaLexer.NOT_EQUAL;
     /**
      * The {@code ==} (equal) operator.
      *
@@ -3514,7 +3516,7 @@ public final class TokenTypes {
      *
      * @see #EXPR
      **/
-    public static final int EQUAL = GeneratedJavaTokenTypes.EQUAL;
+    public static final int EQUAL = JavaLexer.EQUAL;
     /**
      * The {@code <} (less than) operator.
      *
@@ -3535,7 +3537,7 @@ public final class TokenTypes {
      *
      * @see #EXPR
      **/
-    public static final int LT = GeneratedJavaTokenTypes.LT;
+    public static final int LT = JavaLexer.LT;
     /**
      * The {@code >} (greater than) operator.
      *
@@ -3556,7 +3558,7 @@ public final class TokenTypes {
      *
      * @see #EXPR
      **/
-    public static final int GT = GeneratedJavaTokenTypes.GT;
+    public static final int GT = JavaLexer.GT;
     /**
      * The {@code <=} (less than or equal) operator.
      *
@@ -3577,13 +3579,13 @@ public final class TokenTypes {
      *
      * @see #EXPR
      **/
-    public static final int LE = GeneratedJavaTokenTypes.LE;
+    public static final int LE = JavaLexer.LE;
     /**
      * The {@code >=} (greater than or equal) operator.
      *
      * @see #EXPR
      **/
-    public static final int GE = GeneratedJavaTokenTypes.GE;
+    public static final int GE = JavaLexer.GE;
     /**
      * The {@code instanceof} operator.  The first child is an
      * object reference or something that evaluates to an object
@@ -3619,7 +3621,7 @@ public final class TokenTypes {
      * @see FullIdent
      **/
     public static final int LITERAL_INSTANCEOF =
-        GeneratedJavaTokenTypes.LITERAL_instanceof;
+        JavaLexer.LITERAL_INSTANCEOF;
 
     /**
      * The {@code <<} (shift left) operator.
@@ -3644,7 +3646,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.19</a>
      * @see #EXPR
      **/
-    public static final int SL = GeneratedJavaTokenTypes.SL;
+    public static final int SL = JavaLexer.SL;
     /**
      * The {@code >>} (signed shift right) operator.
      *
@@ -3668,7 +3670,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.19</a>
      * @see #EXPR
      **/
-    public static final int SR = GeneratedJavaTokenTypes.SR;
+    public static final int SR = JavaLexer.SR;
     /**
      * The {@code >>>} (unsigned shift right) operator.
      *
@@ -3690,7 +3692,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.19</a>
      * @see #EXPR
      **/
-    public static final int BSR = GeneratedJavaTokenTypes.BSR;
+    public static final int BSR = JavaLexer.BSR;
     /**
      * The {@code +} (addition) operator.
      *
@@ -3714,7 +3716,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.18</a>
      * @see #EXPR
      **/
-    public static final int PLUS = GeneratedJavaTokenTypes.PLUS;
+    public static final int PLUS = JavaLexer.PLUS;
     /**
      * The {@code -} (subtraction) operator.
      *
@@ -3738,7 +3740,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.18</a>
      * @see #EXPR
      **/
-    public static final int MINUS = GeneratedJavaTokenTypes.MINUS;
+    public static final int MINUS = JavaLexer.MINUS;
     /**
      * The {@code /} (division) operator.
      *
@@ -3762,7 +3764,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.17.2</a>
      * @see #EXPR
      **/
-    public static final int DIV = GeneratedJavaTokenTypes.DIV;
+    public static final int DIV = JavaLexer.DIV;
     /**
      * The {@code %} (remainder) operator.
      *
@@ -3786,7 +3788,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.17.3</a>
      * @see #EXPR
      **/
-    public static final int MOD = GeneratedJavaTokenTypes.MOD;
+    public static final int MOD = JavaLexer.MOD;
     /**
      * The {@code ++} (prefix increment) operator.
      *
@@ -3808,7 +3810,7 @@ public final class TokenTypes {
      * @see #EXPR
      * @see #POST_INC
      **/
-    public static final int INC = GeneratedJavaTokenTypes.INC;
+    public static final int INC = JavaLexer.INC;
     /**
      * The {@code --} (prefix decrement) operator.
      *
@@ -3830,7 +3832,7 @@ public final class TokenTypes {
      * @see #EXPR
      * @see #POST_DEC
      **/
-    public static final int DEC = GeneratedJavaTokenTypes.DEC;
+    public static final int DEC = JavaLexer.DEC;
     /**
      * The {@code ~} (bitwise complement) operator.
      *
@@ -3853,7 +3855,7 @@ public final class TokenTypes {
      * Language Specification, &sect;15.15.5</a>
      * @see #EXPR
      **/
-    public static final int BNOT = GeneratedJavaTokenTypes.BNOT;
+    public static final int BNOT = JavaLexer.BNOT;
     /**
      * The <code>&#33;</code> (logical complement) operator.
      *
@@ -3877,7 +3879,7 @@ public final class TokenTypes {
      * @see #EXPR
      * @noinspection HtmlTagCanBeJavadocTag
      **/
-    public static final int LNOT = GeneratedJavaTokenTypes.LNOT;
+    public static final int LNOT = JavaLexer.LNOT;
     /**
      * The {@code true} keyword.
      *
@@ -3905,7 +3907,7 @@ public final class TokenTypes {
      * @see #LITERAL_FALSE
      **/
     public static final int LITERAL_TRUE =
-        GeneratedJavaTokenTypes.LITERAL_true;
+        JavaLexer.LITERAL_TRUE;
 
     /**
      * The {@code false} keyword.
@@ -3934,7 +3936,7 @@ public final class TokenTypes {
      * @see #LITERAL_TRUE
      **/
     public static final int LITERAL_FALSE =
-        GeneratedJavaTokenTypes.LITERAL_false;
+        JavaLexer.LITERAL_FALSE;
 
     /**
      * The {@code null} keyword.
@@ -3962,7 +3964,7 @@ public final class TokenTypes {
      * @see #EXPR
      **/
     public static final int LITERAL_NULL =
-        GeneratedJavaTokenTypes.LITERAL_null;
+        JavaLexer.LITERAL_NULL;
 
     /**
      * The {@code new} keyword.  This element is used to define
@@ -4096,7 +4098,7 @@ public final class TokenTypes {
      * @see #ARRAY_INIT
      * @see FullIdent
      **/
-    public static final int LITERAL_NEW = GeneratedJavaTokenTypes.LITERAL_new;
+    public static final int LITERAL_NEW = JavaLexer.LITERAL_NEW;
     /**
      * An integer literal.  These may be specified in decimal,
      * hexadecimal, or octal form.
@@ -4120,7 +4122,7 @@ public final class TokenTypes {
      * @see #EXPR
      * @see #NUM_LONG
      **/
-    public static final int NUM_INT = GeneratedJavaTokenTypes.NUM_INT;
+    public static final int NUM_INT = JavaLexer.NUM_INT;
     /**
      * A character literal.  This is a (possibly escaped) character
      * enclosed in single quotes.
@@ -4143,7 +4145,7 @@ public final class TokenTypes {
      * @see #EXPR
      **/
     public static final int CHAR_LITERAL =
-        GeneratedJavaTokenTypes.CHAR_LITERAL;
+        JavaLexer.CHAR_LITERAL;
 
     /**
      * A string literal.  This is a sequence of (possibly escaped)
@@ -4170,7 +4172,7 @@ public final class TokenTypes {
      * @see #EXPR
      **/
     public static final int STRING_LITERAL =
-        GeneratedJavaTokenTypes.STRING_LITERAL;
+        JavaLexer.STRING_LITERAL;
 
     /**
      * A single precision floating point literal.  This is a floating
@@ -4195,7 +4197,7 @@ public final class TokenTypes {
      * @see #EXPR
      * @see #NUM_DOUBLE
      **/
-    public static final int NUM_FLOAT = GeneratedJavaTokenTypes.NUM_FLOAT;
+    public static final int NUM_FLOAT = JavaLexer.NUM_FLOAT;
     /**
      * A long integer literal.  These are almost the same as integer
      * literals, but they have an {@code L} or {@code l}
@@ -4220,7 +4222,7 @@ public final class TokenTypes {
      * @see #EXPR
      * @see #NUM_INT
      **/
-    public static final int NUM_LONG = GeneratedJavaTokenTypes.NUM_LONG;
+    public static final int NUM_LONG = JavaLexer.NUM_LONG;
     /**
      * A double precision floating point literal.  This is a floating
      * point number with an optional {@code D} or {@code d}
@@ -4245,7 +4247,7 @@ public final class TokenTypes {
      * @see #EXPR
      * @see #NUM_FLOAT
      **/
-    public static final int NUM_DOUBLE = GeneratedJavaTokenTypes.NUM_DOUBLE;
+    public static final int NUM_DOUBLE = JavaLexer.NUM_DOUBLE;
 
     /**
      * The {@code assert} keyword.  This is only for Java 1.4 and
@@ -4270,7 +4272,7 @@ public final class TokenTypes {
      *     +--SEMI (;)
      * </pre>
      **/
-    public static final int LITERAL_ASSERT = GeneratedJavaTokenTypes.ASSERT;
+    public static final int LITERAL_ASSERT = JavaLexer.ASSERT;
 
     /**
      * A static import declaration.  Static import declarations are optional,
@@ -4303,7 +4305,7 @@ public final class TokenTypes {
      * @see FullIdent
      **/
     public static final int STATIC_IMPORT =
-        GeneratedJavaTokenTypes.STATIC_IMPORT;
+        JavaLexer.STATIC_IMPORT;
 
     /**
      * An enum declaration. Its notable children are
@@ -4354,7 +4356,7 @@ public final class TokenTypes {
      *                 +--LITERAL_PUBLIC (public)
      *             +--TYPE
      *                 |
-     *                 +--LITERAL_void (void)
+     *                 +--LITERAL_VOID (void)
      *             +--IDENT (someMethod)
      *             +--LPAREN (()
      *             +--PARAMETERS
@@ -4377,14 +4379,14 @@ public final class TokenTypes {
      * @see #ENUM_CONSTANT_DEF
      **/
     public static final int ENUM_DEF =
-        GeneratedJavaTokenTypes.ENUM_DEF;
+        JavaLexer.ENUM_DEF;
 
     /**
      * The {@code enum} keyword.  This element appears
      * as part of an enum declaration.
      **/
     public static final int ENUM =
-        GeneratedJavaTokenTypes.ENUM;
+        JavaLexer.ENUM;
 
     /**
      * An enum constant declaration. Its notable children are annotations,
@@ -4424,7 +4426,7 @@ public final class TokenTypes {
      *                 +--LITERAL_PUBLIC (public)
      *             +--TYPE
      *                 |
-     *                 +--LITERAL_void (void)
+     *                 +--LITERAL_VOID (void)
      *             +--IDENT (someMethodOverriddenFromMainBody)
      *             +--LPAREN (()
      *             +--PARAMETERS
@@ -4444,7 +4446,7 @@ public final class TokenTypes {
      * @see #OBJBLOCK
      **/
     public static final int ENUM_CONSTANT_DEF =
-        GeneratedJavaTokenTypes.ENUM_CONSTANT_DEF;
+        JavaLexer.ENUM_CONSTANT_DEF;
 
     /**
      * A for-each clause.  This is a child of
@@ -4486,7 +4488,7 @@ public final class TokenTypes {
      * @see #LITERAL_FOR
      **/
     public static final int FOR_EACH_CLAUSE =
-        GeneratedJavaTokenTypes.FOR_EACH_CLAUSE;
+        JavaLexer.FOR_EACH_CLAUSE;
 
     /**
      * An annotation declaration. The notable children are the name of the
@@ -4529,7 +4531,7 @@ public final class TokenTypes {
      * @see #ANNOTATION_FIELD_DEF
      **/
     public static final int ANNOTATION_DEF =
-        GeneratedJavaTokenTypes.ANNOTATION_DEF;
+        JavaLexer.ANNOTATION_DEF;
 
     /**
      * An annotation field declaration.  The notable children are modifiers,
@@ -4566,7 +4568,7 @@ public final class TokenTypes {
      * @see #LITERAL_DEFAULT
      */
     public static final int ANNOTATION_FIELD_DEF =
-        GeneratedJavaTokenTypes.ANNOTATION_FIELD_DEF;
+        JavaLexer.ANNOTATION_FIELD_DEF;
 
     // note: &#064; is the html escape for '@',
     // used here to avoid confusing the javadoc tool
@@ -4605,7 +4607,7 @@ public final class TokenTypes {
      * @see #IDENT
      */
     public static final int ANNOTATIONS =
-        GeneratedJavaTokenTypes.ANNOTATIONS;
+        JavaLexer.ANNOTATIONS;
 
     // note: &#064; is the html escape for '@',
     // used here to avoid confusing the javadoc tool
@@ -4655,7 +4657,7 @@ public final class TokenTypes {
      * @see #ANNOTATION_MEMBER_VALUE_PAIR
      */
     public static final int ANNOTATION =
-        GeneratedJavaTokenTypes.ANNOTATION;
+        JavaLexer.ANNOTATION;
 
     /**
      * An initialization of an annotation member with a value.
@@ -4668,7 +4670,7 @@ public final class TokenTypes {
      * @see #IDENT
      */
     public static final int ANNOTATION_MEMBER_VALUE_PAIR =
-        GeneratedJavaTokenTypes.ANNOTATION_MEMBER_VALUE_PAIR;
+        JavaLexer.ANNOTATION_MEMBER_VALUE_PAIR;
 
     /**
      * An annotation array member initialization.
@@ -4705,7 +4707,7 @@ public final class TokenTypes {
      * @see #ANNOTATION_MEMBER_VALUE_PAIR
      */
     public static final int ANNOTATION_ARRAY_INIT =
-        GeneratedJavaTokenTypes.ANNOTATION_ARRAY_INIT;
+        JavaLexer.ANNOTATION_ARRAY_INIT;
 
     /**
      * A list of type parameters to a class, interface or
@@ -4750,7 +4752,7 @@ public final class TokenTypes {
      * @see #COMMA
      */
     public static final int TYPE_PARAMETERS =
-        GeneratedJavaTokenTypes.TYPE_PARAMETERS;
+        JavaLexer.TYPE_PARAMETERS;
 
     /**
      * A type parameter to a class, interface or method definition.
@@ -4791,7 +4793,7 @@ public final class TokenTypes {
      * @see #TYPE_UPPER_BOUNDS
      */
     public static final int TYPE_PARAMETER =
-        GeneratedJavaTokenTypes.TYPE_PARAMETER;
+        JavaLexer.TYPE_PARAMETER;
 
     /**
      * A list of type arguments to a type reference or
@@ -4828,7 +4830,7 @@ public final class TokenTypes {
      * @see #COMMA
      */
     public static final int TYPE_ARGUMENTS =
-        GeneratedJavaTokenTypes.TYPE_ARGUMENTS;
+        JavaLexer.TYPE_ARGUMENTS;
 
     /**
      * A type arguments to a type reference or a method/ctor invocation.
@@ -4860,7 +4862,7 @@ public final class TokenTypes {
      * @see #TYPE_LOWER_BOUNDS
      */
     public static final int TYPE_ARGUMENT =
-        GeneratedJavaTokenTypes.TYPE_ARGUMENT;
+        JavaLexer.TYPE_ARGUMENT;
 
     /**
      * The type that refers to all types. This node has no children.
@@ -4891,7 +4893,7 @@ public final class TokenTypes {
      * @see #TYPE_LOWER_BOUNDS
      */
     public static final int WILDCARD_TYPE =
-        GeneratedJavaTokenTypes.WILDCARD_TYPE;
+        JavaLexer.WILDCARD_TYPE;
 
     /**
      * An upper bounds on a wildcard type argument or type parameter.
@@ -4924,7 +4926,7 @@ public final class TokenTypes {
      * @see #WILDCARD_TYPE
      */
     public static final int TYPE_UPPER_BOUNDS =
-        GeneratedJavaTokenTypes.TYPE_UPPER_BOUNDS;
+        JavaLexer.TYPE_UPPER_BOUNDS;
 
     /**
      * A lower bounds on a wildcard type argument. This node has one child
@@ -4956,7 +4958,7 @@ public final class TokenTypes {
      * @see #WILDCARD_TYPE
      */
     public static final int TYPE_LOWER_BOUNDS =
-        GeneratedJavaTokenTypes.TYPE_LOWER_BOUNDS;
+        JavaLexer.TYPE_LOWER_BOUNDS;
 
     /**
      * An {@code @} symbol - signifying an annotation instance or the prefix
@@ -4966,7 +4968,7 @@ public final class TokenTypes {
      * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
      * JSR201</a>
      */
-    public static final int AT = GeneratedJavaTokenTypes.AT;
+    public static final int AT = JavaLexer.AT;
 
     /**
      * A triple dot for variable-length parameters. This token only ever occurs
@@ -4975,7 +4977,7 @@ public final class TokenTypes {
      * @see <a href="https://www.jcp.org/en/jsr/detail?id=201">
      * JSR201</a>
      */
-    public static final int ELLIPSIS = GeneratedJavaTokenTypes.ELLIPSIS;
+    public static final int ELLIPSIS = JavaLexer.ELLIPSIS;
 
     /**
      * The {@code &} symbol when used to extend a generic upper or lower bounds constrain
@@ -5023,23 +5025,23 @@ public final class TokenTypes {
      * Java Language Specification, &sect;15.16</a>
      */
     public static final int TYPE_EXTENSION_AND =
-        GeneratedJavaTokenTypes.TYPE_EXTENSION_AND;
+        JavaLexer.TYPE_EXTENSION_AND;
 
     /**
      * A {@code <} symbol signifying the start of type arguments or type parameters.
      */
     public static final int GENERIC_START =
-        GeneratedJavaTokenTypes.GENERIC_START;
+        JavaLexer.GENERIC_START;
 
     /**
      * A {@code >} symbol signifying the end of type arguments or type parameters.
      */
-    public static final int GENERIC_END = GeneratedJavaTokenTypes.GENERIC_END;
+    public static final int GENERIC_END = JavaLexer.GENERIC_END;
 
     /**
      * Special lambda symbol {@code ->}.
      */
-    public static final int LAMBDA = GeneratedJavaTokenTypes.LAMBDA;
+    public static final int LAMBDA = JavaLexer.LAMBDA;
 
     /**
      * Beginning of single line comment: '//'.
@@ -5061,7 +5063,7 @@ public final class TokenTypes {
      * </pre>
      */
     public static final int SINGLE_LINE_COMMENT =
-            GeneratedJavaTokenTypes.SINGLE_LINE_COMMENT;
+            JavaLexer.SINGLE_LINE_COMMENT;
 
     /**
      * Beginning of block comment: '/*'.
@@ -5078,7 +5080,7 @@ public final class TokenTypes {
      * </pre>
      */
     public static final int BLOCK_COMMENT_BEGIN =
-            GeneratedJavaTokenTypes.BLOCK_COMMENT_BEGIN;
+            JavaLexer.BLOCK_COMMENT_BEGIN;
 
     /**
      * End of block comment: '&#42;/'.
@@ -5091,7 +5093,7 @@ public final class TokenTypes {
      * </pre>
      */
     public static final int BLOCK_COMMENT_END =
-            GeneratedJavaTokenTypes.BLOCK_COMMENT_END;
+            JavaLexer.BLOCK_COMMENT_END;
 
     /**
      * Text of single-line or block comment.
@@ -5115,7 +5117,7 @@ public final class TokenTypes {
      *
      */
     public static final int COMMENT_CONTENT =
-            GeneratedJavaTokenTypes.COMMENT_CONTENT;
+            JavaLexer.COMMENT_CONTENT;
 
     /**
      * A pattern variable definition; when conditionally matched,
@@ -5145,7 +5147,7 @@ public final class TokenTypes {
      * @since 8.35
      */
     public static final int PATTERN_VARIABLE_DEF =
-            GeneratedJavaTokenTypes.PATTERN_VARIABLE_DEF;
+            JavaLexer.PATTERN_VARIABLE_DEF;
 
     /**
      * The {@code record} keyword.  This element appears
@@ -5175,7 +5177,7 @@ public final class TokenTypes {
      * @since 8.35
      **/
     public static final int LITERAL_RECORD =
-            GeneratedJavaTokenTypes.LITERAL_record;
+            JavaLexer.LITERAL_RECORD;
 
     /**
      * A declaration of a record specifies a name, a header, and a body.
@@ -5206,7 +5208,7 @@ public final class TokenTypes {
      * @since 8.35
      */
     public static final int RECORD_DEF =
-            GeneratedJavaTokenTypes.RECORD_DEF;
+            JavaLexer.RECORD_DEF;
 
     /**
      * Record components are a (possibly empty) list containing the components of a record, which
@@ -5245,7 +5247,7 @@ public final class TokenTypes {
      * @since 8.36
      */
     public static final int RECORD_COMPONENTS =
-            GeneratedJavaTokenTypes.RECORD_COMPONENTS;
+            JavaLexer.RECORD_COMPONENTS;
 
     /**
      * A record component is a variable that comprises the state of a record.  Record components
@@ -5288,7 +5290,7 @@ public final class TokenTypes {
      * @since 8.36
      */
     public static final int RECORD_COMPONENT_DEF =
-            GeneratedJavaTokenTypes.RECORD_COMPONENT_DEF;
+            JavaLexer.RECORD_COMPONENT_DEF;
 
     /**
      * A compact canonical constructor eliminates the list of formal parameters; they are
@@ -5324,7 +5326,7 @@ public final class TokenTypes {
      * @since 8.36
      */
     public static final int COMPACT_CTOR_DEF =
-            GeneratedJavaTokenTypes.COMPACT_CTOR_DEF;
+            JavaLexer.COMPACT_CTOR_DEF;
 
     /**
      * Beginning of a Java 14 Text Block literal,
@@ -5354,7 +5356,7 @@ public final class TokenTypes {
      * @since 8.36
      */
     public static final int TEXT_BLOCK_LITERAL_BEGIN =
-            GeneratedJavaTokenTypes.TEXT_BLOCK_LITERAL_BEGIN;
+            JavaLexer.TEXT_BLOCK_LITERAL_BEGIN;
 
     /**
      * Content of a Java 14 text block. This is a
@@ -5385,7 +5387,7 @@ public final class TokenTypes {
      * @since 8.36
      */
     public static final int TEXT_BLOCK_CONTENT =
-            GeneratedJavaTokenTypes.TEXT_BLOCK_CONTENT;
+            JavaLexer.TEXT_BLOCK_CONTENT;
 
     /**
      * End of a Java 14 text block literal, delimited by three
@@ -5415,7 +5417,7 @@ public final class TokenTypes {
      * @since 8.36
      */
     public static final int TEXT_BLOCK_LITERAL_END =
-            GeneratedJavaTokenTypes.TEXT_BLOCK_LITERAL_END;
+            JavaLexer.TEXT_BLOCK_LITERAL_END;
 
     /**
      * The {@code yield} keyword.  This element appears
@@ -5488,7 +5490,7 @@ public final class TokenTypes {
      * @since 8.36
      */
     public static final int LITERAL_YIELD =
-            GeneratedJavaTokenTypes.LITERAL_yield;
+            JavaLexer.LITERAL_YIELD;
 
     /**
      * Switch Expressions.
@@ -5542,7 +5544,7 @@ public final class TokenTypes {
      * @since 8.36
      */
     public static final int SWITCH_RULE =
-            GeneratedJavaTokenTypes.SWITCH_RULE;
+            JavaLexer.SWITCH_RULE;
 
     /**
      * The {@code non-sealed} keyword.  This element appears
@@ -5573,7 +5575,7 @@ public final class TokenTypes {
      * @since 8.42
      */
     public static final int LITERAL_NON_SEALED =
-        GeneratedJavaTokenTypes.LITERAL_non_sealed;
+        JavaLexer.LITERAL_NON_SEALED;
 
     /**
      * The {@code sealed} restricted identifier.  This element appears
@@ -5609,7 +5611,7 @@ public final class TokenTypes {
      * @since 8.42
      */
     public static final int LITERAL_SEALED =
-        GeneratedJavaTokenTypes.LITERAL_sealed;
+        JavaLexer.LITERAL_SEALED;
 
     /**
      * The {@code permits} restricted identifier.  This element appears
@@ -5645,7 +5647,7 @@ public final class TokenTypes {
      * @since 8.42
      */
     public static final int LITERAL_PERMITS =
-        GeneratedJavaTokenTypes.LITERAL_permits;
+        JavaLexer.LITERAL_PERMITS;
 
     /**
      * A permits clause.  A permits clause's children are a comma separated list of one or
@@ -5685,7 +5687,7 @@ public final class TokenTypes {
      * @since 8.42
      */
     public static final int PERMITS_CLAUSE =
-        GeneratedJavaTokenTypes.PERMITS_CLAUSE;
+        JavaLexer.PERMITS_CLAUSE;
 
     /** Prevent instantiation. */
     private TokenTypes() {
diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/checks/ArrayTypeStyleCheck.java b/src/main/java/com/puppycrawl/tools/checkstyle/checks/ArrayTypeStyleCheck.java
--- a/src/main/java/com/puppycrawl/tools/checkstyle/checks/ArrayTypeStyleCheck.java
+++ b/src/main/java/com/puppycrawl/tools/checkstyle/checks/ArrayTypeStyleCheck.java
@@ -147,8 +147,7 @@ public void visitToken(DetailAST ast) {
             // force all methods to be Java style (see note in top Javadoc)
             final boolean isMethodViolation = isMethod && !isJavaStyle;
             final boolean isVariableViolation = !isMethod
-                    && isJavaStyle != javaStyle
-                    && typeAST.getType() != TokenTypes.TYPE_ARGUMENT;
+                    && isJavaStyle != javaStyle;
 
             if (isMethodViolation || isVariableViolation) {
                 log(ast, MSG_KEY);
diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/checks/whitespace/WhitespaceAfterCheck.java b/src/main/java/com/puppycrawl/tools/checkstyle/checks/whitespace/WhitespaceAfterCheck.java
--- a/src/main/java/com/puppycrawl/tools/checkstyle/checks/whitespace/WhitespaceAfterCheck.java
+++ b/src/main/java/com/puppycrawl/tools/checkstyle/checks/whitespace/WhitespaceAfterCheck.java
@@ -188,11 +188,13 @@ private static boolean isFollowedByWhitespace(DetailAST targetAST, String line)
             targetAST.getColumnNo() + targetAST.getText().length();
         boolean followedByWhitespace = true;
 
-        if (after < line.length()) {
-            final char charAfter = line.charAt(after);
-            followedByWhitespace = charAfter == ';'
-                || charAfter == ')'
-                || Character.isWhitespace(charAfter);
+        if (after < line.codePointCount(0, line.length())) {
+            final int[] codePoints = line.codePoints().toArray();
+            final int codePoint = codePoints[after];
+
+            followedByWhitespace = codePoint == ';'
+                || codePoint == ')'
+                || Character.isWhitespace(codePoint);
         }
         return followedByWhitespace;
     }
diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/gui/ParseTreeTablePresentation.java b/src/main/java/com/puppycrawl/tools/checkstyle/gui/ParseTreeTablePresentation.java
--- a/src/main/java/com/puppycrawl/tools/checkstyle/gui/ParseTreeTablePresentation.java
+++ b/src/main/java/com/puppycrawl/tools/checkstyle/gui/ParseTreeTablePresentation.java
@@ -22,8 +22,6 @@
 import java.util.HashMap;
 import java.util.Map;
 
-import antlr.ASTFactory;
-import antlr.collections.AST;
 import com.puppycrawl.tools.checkstyle.DetailAstImpl;
 import com.puppycrawl.tools.checkstyle.JavadocDetailNodeParser;
 import com.puppycrawl.tools.checkstyle.api.DetailAST;
@@ -78,7 +76,7 @@ public ParseTreeTablePresentation(DetailAST parseTree) {
      * @param parseTree DetailAST parse tree.
      */
     protected final void setParseTree(DetailAST parseTree) {
-        ((AST) root).setFirstChild((AST) parseTree);
+        ((DetailAstImpl) root).setFirstChild(parseTree);
     }
 
     /**
@@ -193,7 +191,7 @@ public int getChildCount(Object parent) {
         }
         else {
             if (parseMode == ParseMode.JAVA_WITH_JAVADOC_AND_COMMENTS
-                    && ((AST) parent).getType() == TokenTypes.COMMENT_CONTENT
+                    && ((DetailAST) parent).getType() == TokenTypes.COMMENT_CONTENT
                     && JavadocUtil.isJavadocComment(((DetailAST) parent).getParent())) {
                 // getChildCount return 0 on COMMENT_CONTENT,
                 // but we need to attach javadoc tree, that is separate tree
@@ -266,9 +264,10 @@ public boolean isCellEditable(int column) {
      * @return artificial tree root.
      */
     private static DetailAST createArtificialTreeRoot() {
-        final ASTFactory factory = new ASTFactory();
-        factory.setASTNodeClass(DetailAstImpl.class.getName());
-        return (DetailAST) factory.create(TokenTypes.EOF, "ROOT");
+        final DetailAstImpl root = new DetailAstImpl();
+        root.setType(TokenTypes.EOF);
+        root.setText("ROOT");
+        return root;
     }
 
     /**
diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/utils/JavadocUtil.java b/src/main/java/com/puppycrawl/tools/checkstyle/utils/JavadocUtil.java
--- a/src/main/java/com/puppycrawl/tools/checkstyle/utils/JavadocUtil.java
+++ b/src/main/java/com/puppycrawl/tools/checkstyle/utils/JavadocUtil.java
@@ -59,7 +59,7 @@ public enum JavadocTagType {
     /** Maps from a token name to value. */
     private static final Map<String, Integer> TOKEN_NAME_TO_VALUE;
     /** Maps from a token value to name. */
-    private static final String[] TOKEN_VALUE_TO_NAME;
+    private static final Map<Integer, String> TOKEN_VALUE_TO_NAME;
 
     /** Exception message for unknown JavaDoc token id. */
     private static final String UNKNOWN_JAVADOC_TOKEN_ID_EXCEPTION_MESSAGE = "Unknown javadoc"
@@ -77,7 +77,7 @@ public enum JavadocTagType {
     // initialise the constants
     static {
         TOKEN_NAME_TO_VALUE = TokenUtil.nameToValueMapFromPublicIntFields(JavadocTokenTypes.class);
-        TOKEN_VALUE_TO_NAME = TokenUtil.valueToNameArrayFromNameToValueMap(TOKEN_NAME_TO_VALUE);
+        TOKEN_VALUE_TO_NAME = TokenUtil.invertMap(TOKEN_NAME_TO_VALUE);
     }
 
     /** Prevent instantiation. */
@@ -315,19 +315,10 @@ public static DetailNode getPreviousSibling(DetailNode node) {
      * @throws IllegalArgumentException if an unknown token ID was specified.
      */
     public static String getTokenName(int id) {
-        final String name;
-        if (id == JavadocTokenTypes.EOF) {
-            name = "EOF";
-        }
-        else if (id > TOKEN_VALUE_TO_NAME.length - 1) {
+        final String name = TOKEN_VALUE_TO_NAME.get(id);
+        if (name == null) {
             throw new IllegalArgumentException(UNKNOWN_JAVADOC_TOKEN_ID_EXCEPTION_MESSAGE + id);
         }
-        else {
-            name = TOKEN_VALUE_TO_NAME[id];
-            if (name == null) {
-                throw new IllegalArgumentException(UNKNOWN_JAVADOC_TOKEN_ID_EXCEPTION_MESSAGE + id);
-            }
-        }
         return name;
     }
 
diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/utils/ParserUtil.java b/src/main/java/com/puppycrawl/tools/checkstyle/utils/ParserUtil.java
--- a/src/main/java/com/puppycrawl/tools/checkstyle/utils/ParserUtil.java
+++ b/src/main/java/com/puppycrawl/tools/checkstyle/utils/ParserUtil.java
@@ -22,7 +22,8 @@
 import java.util.AbstractMap;
 import java.util.Map;
 
-import antlr.Token;
+import org.antlr.v4.runtime.CommonToken;
+
 import com.puppycrawl.tools.checkstyle.DetailAstImpl;
 import com.puppycrawl.tools.checkstyle.api.DetailAST;
 import com.puppycrawl.tools.checkstyle.api.TokenTypes;
@@ -79,20 +80,18 @@ public static DetailAST createBlockCommentNode(String content) {
      * @param token Token object.
      * @return DetailAST with BLOCK_COMMENT type.
      */
-    public static DetailAST createBlockCommentNode(Token token) {
+    public static DetailAST createBlockCommentNode(CommonToken token) {
         final DetailAstImpl blockComment = new DetailAstImpl();
         blockComment.initialize(TokenTypes.BLOCK_COMMENT_BEGIN, BLOCK_MULTIPLE_COMMENT_BEGIN);
 
-        // column counting begins from 0
-        blockComment.setColumnNo(token.getColumn() - 1);
+        blockComment.setColumnNo(token.getCharPositionInLine());
         blockComment.setLineNo(token.getLine());
 
         final DetailAstImpl blockCommentContent = new DetailAstImpl();
         blockCommentContent.setType(TokenTypes.COMMENT_CONTENT);
 
-        // column counting begins from 0
-        // plus length of '/*'
-        blockCommentContent.setColumnNo(token.getColumn() - 1 + 2);
+        // Add length of '/*'
+        blockCommentContent.setColumnNo(token.getCharPositionInLine() + 2);
         blockCommentContent.setLineNo(token.getLine());
         blockCommentContent.setText(token.getText());
 
@@ -100,7 +99,7 @@ public static DetailAST createBlockCommentNode(Token token) {
         blockCommentClose.initialize(TokenTypes.BLOCK_COMMENT_END, BLOCK_MULTIPLE_COMMENT_END);
 
         final Map.Entry<Integer, Integer> linesColumns = countLinesColumns(
-            token.getText(), token.getLine(), token.getColumn());
+            token.getText(), token.getLine(), token.getCharPositionInLine() + 1);
         blockCommentClose.setLineNo(linesColumns.getKey());
         blockCommentClose.setColumnNo(linesColumns.getValue());
 
diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/utils/TokenUtil.java b/src/main/java/com/puppycrawl/tools/checkstyle/utils/TokenUtil.java
--- a/src/main/java/com/puppycrawl/tools/checkstyle/utils/TokenUtil.java
+++ b/src/main/java/com/puppycrawl/tools/checkstyle/utils/TokenUtil.java
@@ -43,7 +43,7 @@ public final class TokenUtil {
     /** Maps from a token name to value. */
     private static final Map<String, Integer> TOKEN_NAME_TO_VALUE;
     /** Maps from a token value to name. */
-    private static final String[] TOKEN_VALUE_TO_NAME;
+    private static final Map<Integer, String> TOKEN_VALUE_TO_NAME;
 
     /** Array of all token IDs. */
     private static final int[] TOKEN_IDS;
@@ -57,7 +57,7 @@ public final class TokenUtil {
     // initialise the constants
     static {
         TOKEN_NAME_TO_VALUE = nameToValueMapFromPublicIntFields(TokenTypes.class);
-        TOKEN_VALUE_TO_NAME = valueToNameArrayFromNameToValueMap(TOKEN_NAME_TO_VALUE);
+        TOKEN_VALUE_TO_NAME = invertMap(TOKEN_NAME_TO_VALUE);
         TOKEN_IDS = TOKEN_NAME_TO_VALUE.values().stream().mapToInt(Integer::intValue).toArray();
     }
 
@@ -100,27 +100,14 @@ public static Map<String, Integer> nameToValueMapFromPublicIntFields(Class<?> cl
     }
 
     /**
-     * Creates an array of map keys for quick value-to-name lookup for the map.
+     * Inverts a given map by exchanging each entry's key and value.
      *
      * @param map source map
-     * @return array of map keys
+     * @return inverted map
      */
-    public static String[] valueToNameArrayFromNameToValueMap(Map<String, Integer> map) {
-        String[] valueToNameArray = CommonUtil.EMPTY_STRING_ARRAY;
-
-        for (Map.Entry<String, Integer> entry : map.entrySet()) {
-            final int value = entry.getValue();
-            // JavadocTokenTypes.EOF has value '-1' and is handled explicitly.
-            if (value >= 0) {
-                if (value >= valueToNameArray.length) {
-                    final String[] temp = new String[value + 1];
-                    System.arraycopy(valueToNameArray, 0, temp, 0, valueToNameArray.length);
-                    valueToNameArray = temp;
-                }
-                valueToNameArray[value] = entry.getKey();
-            }
-        }
-        return valueToNameArray;
+    public static Map<Integer, String> invertMap(Map<String, Integer> map) {
+        return map.entrySet().stream()
+            .collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey));
     }
 
     /**
@@ -151,11 +138,7 @@ public static int[] getAllTokenIds() {
      * @throws IllegalArgumentException when id is not valid
      */
     public static String getTokenName(int id) {
-        if (id > TOKEN_VALUE_TO_NAME.length - 1) {
-            throw new IllegalArgumentException(
-                String.format(Locale.ROOT, TOKEN_ID_EXCEPTION_FORMAT, id));
-        }
-        final String name = TOKEN_VALUE_TO_NAME[id];
+        final String name = TOKEN_VALUE_TO_NAME.get(id);
         if (name == null) {
             throw new IllegalArgumentException(
                 String.format(Locale.ROOT, TOKEN_ID_EXCEPTION_FORMAT, id));

diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/AstTreeStringPrinterTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/AstTreeStringPrinterTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/AstTreeStringPrinterTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/AstTreeStringPrinterTest.java
@@ -34,7 +34,6 @@
 
 import org.junit.jupiter.api.Test;
 
-import antlr.NoViableAltException;
 import com.puppycrawl.tools.checkstyle.api.CheckstyleException;
 import com.puppycrawl.tools.checkstyle.api.DetailAST;
 import com.puppycrawl.tools.checkstyle.api.FileText;
@@ -61,9 +60,9 @@ public void testParseFileThrowable() throws Exception {
             fail("exception expected");
         }
         catch (CheckstyleException ex) {
-            assertSame(NoViableAltException.class, ex.getCause().getClass(), "Invalid class");
-            assertEquals(input.getAbsolutePath() + ":2:1: unexpected token: classD",
-                    ex.getCause().toString(), "Invalid exception message");
+            assertSame(IllegalStateException.class, ex.getCause().getClass(), "Invalid class");
+            assertEquals("2:0: no viable alternative at input 'classD'",
+                    ex.getCause().getMessage(), "Invalid exception message");
         }
     }
 
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/DetailAstImplTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/DetailAstImplTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/DetailAstImplTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/DetailAstImplTest.java
@@ -25,6 +25,7 @@
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNotSame;
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.io.File;
@@ -43,11 +44,11 @@
 import java.util.Set;
 import java.util.function.Consumer;
 
+import org.antlr.v4.runtime.CommonToken;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 import org.powermock.reflect.Whitebox;
 
-import antlr.CommonHiddenStreamToken;
 import com.puppycrawl.tools.checkstyle.api.DetailAST;
 import com.puppycrawl.tools.checkstyle.api.TokenTypes;
 import com.puppycrawl.tools.checkstyle.checks.TodoCommentCheck;
@@ -97,7 +98,10 @@ public void testInitialize() {
         ast.setColumnNo(3);
 
         final DetailAstImpl copy = new DetailAstImpl();
-        copy.initialize(ast);
+        copy.setText(ast.getText());
+        copy.setType(ast.getType());
+        copy.setLineNo(ast.getLineNo());
+        copy.setColumnNo(ast.getColumnNo());
 
         assertEquals("test", copy.getText(), "Invalid text");
         assertEquals(1, copy.getType(), "Invalid type");
@@ -107,11 +111,10 @@ public void testInitialize() {
 
     @Test
     public void testInitializeToken() {
-        final CommonHiddenStreamToken token = new CommonHiddenStreamToken();
+        final CommonToken token = new CommonToken(1);
         token.setText("test");
-        token.setType(1);
         token.setLine(2);
-        token.setColumn(4);
+        token.setCharPositionInLine(3);
 
         final DetailAstImpl ast = new DetailAstImpl();
         ast.initialize(token);
@@ -144,7 +147,7 @@ public void testGetChildCount() throws Exception {
         assertEquals(0, firstLevelB.getChildCount(), "Invalid child count");
         assertEquals(1, firstLevelA.getChildCount(), "Invalid child count");
         assertEquals(2, root.getChildCount(), "Invalid child count");
-        assertEquals(2, root.getChildCount(), "Invalid child count");
+        assertEquals(2, root.getNumberOfChildren(), "Invalid child count");
 
         assertNull(root.getPreviousSibling(), "Previous sibling should be null");
         assertNull(firstLevelA.getPreviousSibling(), "Previous sibling should be null");
@@ -395,7 +398,7 @@ public void testAddNextSiblingNullParent() {
 
         assertEquals(oldParent, newSibling.getParent(), "Invalid parent");
         assertNull(newSibling.getNextSibling(), "Invalid next sibling");
-        assertEquals(newSibling, child.getNextSibling(), "Invalid child");
+        assertSame(newSibling, child.getNextSibling(), "Invalid child");
     }
 
     @Test
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/JavaAstVisitorTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/JavaAstVisitorTest.java
new file mode 100644
--- /dev/null
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/JavaAstVisitorTest.java
@@ -0,0 +1,192 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2021 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.puppycrawl.tools.checkstyle;
+
+import static com.google.common.truth.Truth.assertWithMessage;
+
+import java.io.File;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.junit.jupiter.api.Test;
+
+import com.puppycrawl.tools.checkstyle.api.DetailAST;
+import com.puppycrawl.tools.checkstyle.api.TokenTypes;
+import com.puppycrawl.tools.checkstyle.grammar.java.CheckstyleJavaParserBaseVisitor;
+
+public class JavaAstVisitorTest {
+
+    /**
+     * If a visit method is not overridden, we should explain why we do not 'visit' the
+     * parse tree at this node and construct an AST. Reasons could include that we have
+     * no terminal symbols (tokens) in the corresponding production rule, or that
+     * we handle the construction of this particular AST in it's parent node. If we
+     * have a production rule where we have terminal symbols (tokens), but we do not build
+     * an AST from tokens in the rule context, the rule is extraneous.
+     */
+    private static final List<String> VISIT_METHODS_NOT_OVERRIDDEN = Arrays.asList(
+            // no tokens in production rule, so no AST to build
+            "visitClassOrInterfaceOrPrimitiveType",
+            "visitNonWildcardTypeArgs",
+            "visitStat",
+            "visitAnnotationConstantRest",
+            "visitSwitchLabeledRule",
+            "visitLocalVariableDeclaration",
+            "visitTypes",
+            "visitSwitchStat",
+            "visitSwitchPrimary",
+            "visitClassDef",
+            "visitInterfaceMemberDeclaration",
+            "visitMemberDeclaration",
+            "visitLiteralPrimary",
+            "visitPatternDefinition",
+            "visitLocalType",
+            "visitLocalTypeDeclaration",
+            "visitRecordBodyDeclaration",
+            "visitResource",
+            "visitVariableInitializer",
+            "visitLambdaBody",
+
+            // AST built in parent rule
+            "visitCreatedNameExtended",
+            "visitSuperSuffixSimple",
+            "visitFieldAccessNoIdent",
+            "visitClassType",
+            "visitClassOrInterfaceTypeExtended"
+    );
+
+    @Test
+    public void testAllVisitMethodsAreOverridden() {
+        final Method[] baseVisitMethods = CheckstyleJavaParserBaseVisitor
+                .class.getDeclaredMethods();
+        final Method[] visitMethods = JavaAstVisitor.class.getDeclaredMethods();
+
+        final Set<String> filteredBaseVisitMethodNames = Arrays.stream(baseVisitMethods)
+                .filter(method -> !VISIT_METHODS_NOT_OVERRIDDEN.contains(method.getName()))
+                .filter(method -> method.getName().contains("visit"))
+                .filter(method -> method.getModifiers() == Modifier.PUBLIC)
+                .map(Method::getName)
+                .collect(Collectors.toSet());
+
+        final Set<String> filteredVisitMethodNames = Arrays.stream(visitMethods)
+                .filter(method -> method.getName().contains("visit"))
+                .filter(method -> method.getModifiers() == Modifier.PUBLIC)
+                .map(Method::getName)
+                .collect(Collectors.toSet());
+
+        // remove overridden 'visit' method from ParseTreeVisitor interface in JavaAstVisitor
+        filteredVisitMethodNames.removeIf(name -> name.matches("visit"));
+
+        final String message = "Visit methods in 'CheckstyleJavaParserBaseVisitor' generated from "
+                + "production rules and labeled alternatives in 'CheckstyleJavaParser.g4' should "
+                + "be overridden in 'JavaAstVisitor' or be added to 'VISIT_METHODS_NOT_OVERRIDDEN' "
+                + "with comment explaining why.";
+
+        assertWithMessage(message)
+                .that(filteredVisitMethodNames)
+                .containsExactlyElementsIn(filteredBaseVisitMethodNames);
+    }
+
+    @Test
+    public void testOrderOfVisitMethodsAndProductionRules() throws Exception {
+        // Order of BaseVisitor's generated 'visit' methods match the order of
+        // production rules in 'CheckstyleJavaParser.g4'.
+        final String baseVisitorFilename = "target/generated-sources/antlr/com/puppycrawl"
+                + "/tools/checkstyle/grammar/java/CheckstyleJavaParserBaseVisitor.java";
+        final DetailAST baseVisitorAst = JavaParser.parseFile(new File(baseVisitorFilename),
+                            JavaParser.Options.WITHOUT_COMMENTS);
+
+        final String visitorFilename = "src/main/java/com/puppycrawl/tools/checkstyle"
+                + "/JavaAstVisitor.java";
+        final DetailAST visitorAst = JavaParser.parseFile(new File(visitorFilename),
+                            JavaParser.Options.WITHOUT_COMMENTS);
+
+        final List<String> orderedBaseVisitorMethodNames =
+                getOrderedVisitMethodNames(baseVisitorAst);
+        final List<String> orderedVisitorMethodNames =
+                getOrderedVisitMethodNames(visitorAst);
+
+        orderedBaseVisitorMethodNames.removeAll(VISIT_METHODS_NOT_OVERRIDDEN);
+
+        // remove overridden 'visit' method from ParseTreeVisitor interface in JavaAstVisitor
+        orderedVisitorMethodNames.removeIf(name -> name.matches("visit"));
+
+        assertWithMessage("Visit methods in 'JavaAstVisitor' should appear in same order as "
+                + "production rules and labeled alternatives in 'CheckstyleJavaParser.g4'.")
+                .that(orderedVisitorMethodNames)
+                .containsExactlyElementsIn(orderedBaseVisitorMethodNames)
+                .inOrder();
+    }
+
+    /**
+     * Finds all {@code visit...} methods in a source file, and collects
+     * the method names into a list. This method counts on the simple structure
+     * of 'JavaAstVisitor' and 'CheckstyleJavaParserBaseVisitor'.
+     *
+     * @param root the root of the AST to extract method names from
+     * @return list of all {@code visit...} method names
+     */
+    private static List<String> getOrderedVisitMethodNames(DetailAST root) {
+        final List<String> orderedVisitMethodNames = new ArrayList<>();
+
+        DetailAST classDef = root;
+        while (classDef.getType() != TokenTypes.CLASS_DEF) {
+            classDef = classDef.getNextSibling();
+        }
+
+        final DetailAST objBlock = classDef.findFirstToken(TokenTypes.OBJBLOCK);
+        DetailAST objBlockChild = objBlock.findFirstToken(TokenTypes.METHOD_DEF);
+        while (objBlockChild != null) {
+            if (isVisitMethod(objBlockChild)) {
+                orderedVisitMethodNames.add(objBlockChild
+                        .findFirstToken(TokenTypes.IDENT)
+                        .getText());
+            }
+            objBlockChild = objBlockChild.getNextSibling();
+        }
+        return orderedVisitMethodNames;
+    }
+
+    /**
+     * Checks if given AST is a visit method.
+     *
+     * @param objBlockChild AST to check
+     * @return true if AST is a visit method
+     */
+    private static boolean isVisitMethod(DetailAST objBlockChild) {
+        return objBlockChild.getType() == TokenTypes.METHOD_DEF
+                && objBlockChild.findFirstToken(TokenTypes.IDENT).getText().contains("visit");
+    }
+
+    @Test
+    public void testNullSelfInAddLastSibling() throws Exception {
+        final Method addLastSibling = JavaAstVisitor.class
+                .getDeclaredMethod("addLastSibling", DetailAstImpl.class, DetailAstImpl.class);
+        addLastSibling.setAccessible(true);
+        assertWithMessage("Method should not throw exception.")
+                .that(addLastSibling.invoke(JavaAstVisitor.class, null, null))
+                .isNull();
+    }
+}
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/JavaParserTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/JavaParserTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/JavaParserTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/JavaParserTest.java
@@ -19,6 +19,7 @@
 
 package com.puppycrawl.tools.checkstyle;
 
+import static com.google.common.truth.Truth.assertWithMessage;
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -35,7 +36,6 @@
 
 import org.junit.jupiter.api.Test;
 
-import antlr.NoViableAltException;
 import com.puppycrawl.tools.checkstyle.api.CheckstyleException;
 import com.puppycrawl.tools.checkstyle.api.DetailAST;
 import com.puppycrawl.tools.checkstyle.api.TokenTypes;
@@ -156,11 +156,12 @@ public void testParseException() throws Exception {
         catch (CheckstyleException ex) {
             assertEquals(
                     CheckstyleException.class.getName()
-                            + ": NoViableAltException occurred while parsing file "
+                            + ": IllegalStateException occurred while parsing file "
                             + input.getAbsolutePath() + ".",
                     ex.toString(), "Invalid exception message");
-            assertSame(NoViableAltException.class, ex.getCause().getClass(), "Invalid class");
-            assertEquals(input.getAbsolutePath() + ":2:1: unexpected token: classD",
+            assertSame(IllegalStateException.class, ex.getCause().getClass(), "Invalid class");
+            assertEquals(IllegalStateException.class.getName()
+                            + ": 2:0: no viable alternative at input 'classD'",
                     ex.getCause().toString(), "Invalid exception message");
         }
     }
@@ -200,6 +201,15 @@ public void testJava14TextBlocks() throws Exception {
         assertEquals(expectedContents, content.getText(), "Unexpected text block content");
     }
 
+    @Test
+    public void testNoStackOverflowOnDeepStringConcat() throws Exception {
+        final File file =
+                new File(getPath("InputJavaParserNoStackOverflowOnDeepStringConcat.java"));
+        assertWithMessage("File parsing should not throw StackOverflowError.")
+                .that(JavaParser.parseFile(file, JavaParser.Options.WITH_COMMENTS))
+                .isNotNull();
+    }
+
     private static final class CountComments {
         private final List<String> lineComments = new ArrayList<>();
         private final List<String> blockComments = new ArrayList<>();
@@ -221,5 +231,4 @@ else if (ast.getType() == TokenTypes.BLOCK_COMMENT_BEGIN) {
             }
         }
     }
-
 }
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/JavadocPropertiesGeneratorTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/JavadocPropertiesGeneratorTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/JavadocPropertiesGeneratorTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/JavadocPropertiesGeneratorTest.java
@@ -39,7 +39,6 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 
-import antlr.MismatchedTokenException;
 import com.puppycrawl.tools.checkstyle.api.CheckstyleException;
 import com.puppycrawl.tools.checkstyle.internal.utils.TestUtil;
 
@@ -278,9 +277,9 @@ public void testParseError() throws Exception {
             assertTrue(ex.getMessage().contains("InputJavadocPropertiesGeneratorParseError.java"),
                     "Invalid error message");
 
-            final Throwable cause = ex.getCause().getCause();
-            assertTrue(cause instanceof MismatchedTokenException, "Invalid error message");
-            assertTrue(cause.getMessage().contains("expecting RCURLY, found '!'"),
+            final Throwable cause = ex.getCause();
+            assertTrue(cause instanceof IllegalStateException, "Invalid error message");
+            assertTrue(cause.getMessage().contains("9:0: mismatched input '!' expecting '}'"),
                     "Invalid error message");
         }
     }
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/MainTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/MainTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/MainTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/MainTest.java
@@ -838,13 +838,41 @@ public void testFileReferenceDuringException(@SysErr Capturable systemErr) {
             invokeMain("-c", getPath("InputMainConfig-classname.xml"),
                     getNonCompilablePath("InputMainIncorrectClass.java"));
         });
-        final String exceptionFirstLine = addEndOfLine("com.puppycrawl.tools.checkstyle.api."
+        final String exceptionMessage = addEndOfLine("com.puppycrawl.tools.checkstyle.api."
                 + "CheckstyleException: Exception was thrown while processing "
                 + new File(getNonCompilablePath("InputMainIncorrectClass.java")).getPath());
-        assertTrue(systemErr.getCapturedData().startsWith(exceptionFirstLine),
+        assertTrue(systemErr.getCapturedData().contains(exceptionMessage),
                 "Unexpected system error log");
     }
 
+    @Test
+    public void testRemoveLexerDefaultErrorListener(@SysErr Capturable systemErr) {
+        assertExitWithStatus(-2, () -> {
+            invokeMain("-t", getNonCompilablePath("InputMainIncorrectClass.java"));
+        });
+
+        assertWithMessage("First line of exception message should not contain lexer error.")
+            .that(systemErr.getCapturedData().startsWith("line 2:2 token recognition error"))
+                .isFalse();
+    }
+
+    @Test
+    public void testRemoveParserDefaultErrorListener(@SysErr Capturable systemErr) {
+        assertExitWithStatus(-2, () -> {
+            invokeMain("-t", getNonCompilablePath("InputMainIncorrectClass.java"));
+        });
+
+        final String capturedData = systemErr.getCapturedData();
+
+        assertWithMessage("First line of exception message should not contain parser error.")
+            .that(capturedData.startsWith("line 2:0 no viable alternative"))
+                .isFalse();
+        assertWithMessage("Second line of exception message should not contain parser error.")
+            .that(capturedData.startsWith("line 2:0 no viable alternative",
+                    capturedData.indexOf('\n') + 1))
+                .isFalse();
+    }
+
     @Test
     public void testPrintTreeOnMoreThanOneFile(@SysErr Capturable systemErr,
             @SysOut Capturable systemOut) {
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/SuppressionsStringPrinterTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/SuppressionsStringPrinterTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/SuppressionsStringPrinterTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/SuppressionsStringPrinterTest.java
@@ -29,7 +29,6 @@
 
 import org.junit.jupiter.api.Test;
 
-import antlr.NoViableAltException;
 import com.puppycrawl.tools.checkstyle.api.CheckstyleException;
 
 public class SuppressionsStringPrinterTest extends AbstractTreeTestSupport {
@@ -119,8 +118,9 @@ public void testParseFileTextThrowable() throws Exception {
             fail("exception expected");
         }
         catch (CheckstyleException ex) {
-            assertSame(NoViableAltException.class, ex.getCause().getClass(), "Invalid class");
-            assertEquals(input.getAbsolutePath() + ":2:1: unexpected token: classD",
+            assertSame(IllegalStateException.class, ex.getCause().getClass(), "Invalid class");
+            assertEquals(IllegalStateException.class.getName()
+                            + ": 2:0: no viable alternative at input 'classD'",
                     ex.getCause().toString(), "Invalid exception message");
         }
     }
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/TreeWalkerTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/TreeWalkerTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/TreeWalkerTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/TreeWalkerTest.java
@@ -229,7 +229,7 @@ public void testProcessNonJavaFiles() throws Exception {
             fail("Exception expected");
         }
         catch (CheckstyleException ex) {
-            assertEquals("MismatchedTokenException occurred while parsing file input.java.",
+            assertEquals("IllegalStateException occurred while parsing file input.java.",
                 ex.getMessage(), "Invalid exception message");
         }
     }
@@ -301,7 +301,7 @@ public void testProcessWithRecognitionException() throws Exception {
         }
         catch (CheckstyleException exception) {
             assertTrue(exception.getMessage().contains(
-                    "TokenStreamRecognitionException occurred while parsing file"),
+                    "IllegalStateException occurred while parsing file"),
                     "Error message is unexpected");
         }
     }
@@ -353,8 +353,7 @@ public void testBehaviourWithOrdinaryAndCommentChecks() throws Exception {
             fail("file is not compilable, exception is expected");
         }
         catch (CheckstyleException exception) {
-            final String message =
-                    "TokenStreamRecognitionException occurred while parsing file";
+            final String message = "IllegalStateException occurred while parsing file";
             assertTrue(exception.getMessage().contains(message),
                     "Error message is unexpected");
         }
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/checks/UncommentedMainCheckTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/checks/UncommentedMainCheckTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/checks/UncommentedMainCheckTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/checks/UncommentedMainCheckTest.java
@@ -25,9 +25,9 @@
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.fail;
 
+import org.antlr.v4.runtime.CommonToken;
 import org.junit.jupiter.api.Test;
 
-import antlr.CommonHiddenStreamToken;
 import com.puppycrawl.tools.checkstyle.AbstractModuleTestSupport;
 import com.puppycrawl.tools.checkstyle.DefaultConfiguration;
 import com.puppycrawl.tools.checkstyle.DetailAstImpl;
@@ -116,7 +116,7 @@ public void testWrongArrayType() throws Exception {
     public void testIllegalStateException() {
         final UncommentedMainCheck check = new UncommentedMainCheck();
         final DetailAstImpl ast = new DetailAstImpl();
-        ast.initialize(new CommonHiddenStreamToken(TokenTypes.CTOR_DEF, "ctor"));
+        ast.initialize(new CommonToken(TokenTypes.CTOR_DEF, "ctor"));
         try {
             check.visitToken(ast);
             fail("IllegalStateException is expected");
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/RequireThisCheckTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/RequireThisCheckTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/RequireThisCheckTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/checks/coding/RequireThisCheckTest.java
@@ -31,9 +31,9 @@
 import java.util.Optional;
 import java.util.SortedSet;
 
+import org.antlr.v4.runtime.CommonToken;
 import org.junit.jupiter.api.Test;
 
-import antlr.CommonHiddenStreamToken;
 import com.puppycrawl.tools.checkstyle.AbstractModuleTestSupport;
 import com.puppycrawl.tools.checkstyle.DefaultConfiguration;
 import com.puppycrawl.tools.checkstyle.DetailAstImpl;
@@ -207,7 +207,7 @@ public void testDefaultSwitch() {
         final RequireThisCheck check = new RequireThisCheck();
 
         final DetailAstImpl ast = new DetailAstImpl();
-        ast.initialize(new CommonHiddenStreamToken(TokenTypes.ENUM, "ENUM"));
+        ast.initialize(new CommonToken(TokenTypes.ENUM, "ENUM"));
 
         check.visitToken(ast);
         final SortedSet<Violation> violations = check.getViolations();
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/checks/design/MutableExceptionCheckTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/checks/design/MutableExceptionCheckTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/checks/design/MutableExceptionCheckTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/checks/design/MutableExceptionCheckTest.java
@@ -26,9 +26,9 @@
 import java.util.Arrays;
 import java.util.List;
 
+import org.antlr.v4.runtime.CommonToken;
 import org.junit.jupiter.api.Test;
 
-import antlr.CommonHiddenStreamToken;
 import com.google.common.collect.ImmutableMap;
 import com.puppycrawl.tools.checkstyle.AbstractModuleTestSupport;
 import com.puppycrawl.tools.checkstyle.DefaultConfiguration;
@@ -120,7 +120,7 @@ public void testGetRequiredTokens() {
     public void testWrongTokenType() {
         final MutableExceptionCheck obj = new MutableExceptionCheck();
         final DetailAstImpl ast = new DetailAstImpl();
-        ast.initialize(new CommonHiddenStreamToken(TokenTypes.INTERFACE_DEF, "interface"));
+        ast.initialize(new CommonToken(TokenTypes.INTERFACE_DEF, "interface"));
         try {
             obj.visitToken(ast);
             assertWithMessage("IllegalStateException is expected")
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/checks/design/ThrowsCountCheckTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/checks/design/ThrowsCountCheckTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/checks/design/ThrowsCountCheckTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/checks/design/ThrowsCountCheckTest.java
@@ -24,9 +24,9 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.fail;
 
+import org.antlr.v4.runtime.CommonToken;
 import org.junit.jupiter.api.Test;
 
-import antlr.CommonHiddenStreamToken;
 import com.puppycrawl.tools.checkstyle.AbstractModuleTestSupport;
 import com.puppycrawl.tools.checkstyle.DefaultConfiguration;
 import com.puppycrawl.tools.checkstyle.DetailAstImpl;
@@ -84,7 +84,7 @@ public void testGetRequiredTokens() {
     public void testWrongTokenType() {
         final ThrowsCountCheck obj = new ThrowsCountCheck();
         final DetailAstImpl ast = new DetailAstImpl();
-        ast.initialize(new CommonHiddenStreamToken(TokenTypes.CLASS_DEF, "class"));
+        ast.initialize(new CommonToken(TokenTypes.CLASS_DEF, "class"));
         try {
             obj.visitToken(ast);
             fail("IllegalStateException is expected");
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/checks/design/VisibilityModifierCheckTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/checks/design/VisibilityModifierCheckTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/checks/design/VisibilityModifierCheckTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/checks/design/VisibilityModifierCheckTest.java
@@ -28,10 +28,10 @@
 import java.io.File;
 import java.lang.reflect.Method;
 
+import org.antlr.v4.runtime.CommonToken;
 import org.junit.jupiter.api.Test;
 import org.powermock.reflect.Whitebox;
 
-import antlr.CommonHiddenStreamToken;
 import com.puppycrawl.tools.checkstyle.AbstractModuleTestSupport;
 import com.puppycrawl.tools.checkstyle.DefaultConfiguration;
 import com.puppycrawl.tools.checkstyle.DetailAstImpl;
@@ -419,7 +419,7 @@ public void testPublicFinalFieldInEnum() throws Exception {
     public void testWrongTokenType() {
         final VisibilityModifierCheck obj = new VisibilityModifierCheck();
         final DetailAstImpl ast = new DetailAstImpl();
-        ast.initialize(new CommonHiddenStreamToken(TokenTypes.CLASS_DEF, "class"));
+        ast.initialize(new CommonToken(TokenTypes.CLASS_DEF, "class"));
         try {
             obj.visitToken(ast);
             fail("exception expected");
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/checks/imports/ImportOrderCheckTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/checks/imports/ImportOrderCheckTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/checks/imports/ImportOrderCheckTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/checks/imports/ImportOrderCheckTest.java
@@ -26,9 +26,9 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
+import org.antlr.v4.runtime.CommonToken;
 import org.junit.jupiter.api.Test;
 
-import antlr.CommonHiddenStreamToken;
 import com.puppycrawl.tools.checkstyle.AbstractModuleTestSupport;
 import com.puppycrawl.tools.checkstyle.DefaultConfiguration;
 import com.puppycrawl.tools.checkstyle.DetailAstImpl;
@@ -689,10 +689,10 @@ public void testMultiplePatternMatches() throws Exception {
     @Test
     public void testVisitTokenSwitchReflection() throws Exception {
         // Create mock ast
-        final DetailAstImpl astImport = mockAST(TokenTypes.IMPORT, "import", "mockfile", 0, 0);
-        final DetailAstImpl astIdent = mockAST(TokenTypes.IDENT, "myTestImport", "mockfile", 0, 0);
+        final DetailAstImpl astImport = mockAST(TokenTypes.IMPORT, "import", 0, 0);
+        final DetailAstImpl astIdent = mockAST(TokenTypes.IDENT, "myTestImport", 0, 0);
         astImport.addChild(astIdent);
-        final DetailAST astSemi = mockAST(TokenTypes.SEMI, ";", "mockfile", 0, 0);
+        final DetailAST astSemi = mockAST(TokenTypes.SEMI, ";", 0, 0);
         astIdent.addNextSibling(astSemi);
 
         // Set unsupported option
@@ -714,19 +714,15 @@ public void testVisitTokenSwitchReflection() throws Exception {
      *
      * @param tokenType type of token
      * @param tokenText text of token
-     * @param tokenFileName file name of token
      * @param tokenRow token position in a file (row)
      * @param tokenColumn token position in a file (column)
      * @return AST node for the token
      */
     private static DetailAstImpl mockAST(final int tokenType, final String tokenText,
-            final String tokenFileName, final int tokenRow, final int tokenColumn) {
-        final CommonHiddenStreamToken tokenImportSemi = new CommonHiddenStreamToken();
-        tokenImportSemi.setType(tokenType);
-        tokenImportSemi.setText(tokenText);
+            final int tokenRow, final int tokenColumn) {
+        final CommonToken tokenImportSemi = new CommonToken(tokenType, tokenText);
         tokenImportSemi.setLine(tokenRow);
-        tokenImportSemi.setColumn(tokenColumn);
-        tokenImportSemi.setFilename(tokenFileName);
+        tokenImportSemi.setCharPositionInLine(tokenColumn);
         final DetailAstImpl astSemi = new DetailAstImpl();
         astSemi.initialize(tokenImportSemi);
         return astSemi;
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/checks/metrics/BooleanExpressionComplexityCheckTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/checks/metrics/BooleanExpressionComplexityCheckTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/checks/metrics/BooleanExpressionComplexityCheckTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/checks/metrics/BooleanExpressionComplexityCheckTest.java
@@ -23,9 +23,9 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.fail;
 
+import org.antlr.v4.runtime.CommonToken;
 import org.junit.jupiter.api.Test;
 
-import antlr.CommonHiddenStreamToken;
 import com.puppycrawl.tools.checkstyle.AbstractModuleTestSupport;
 import com.puppycrawl.tools.checkstyle.DefaultConfiguration;
 import com.puppycrawl.tools.checkstyle.DetailAstImpl;
@@ -82,7 +82,7 @@ public void testWrongToken() {
         final BooleanExpressionComplexityCheck booleanExpressionComplexityCheckObj =
             new BooleanExpressionComplexityCheck();
         final DetailAstImpl ast = new DetailAstImpl();
-        ast.initialize(new CommonHiddenStreamToken(TokenTypes.INTERFACE_DEF, "interface"));
+        ast.initialize(new CommonToken(TokenTypes.INTERFACE_DEF, "interface"));
         try {
             booleanExpressionComplexityCheckObj.visitToken(ast);
             fail("exception expected");
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/checks/metrics/ClassDataAbstractionCouplingCheckTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/checks/metrics/ClassDataAbstractionCouplingCheckTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/checks/metrics/ClassDataAbstractionCouplingCheckTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/checks/metrics/ClassDataAbstractionCouplingCheckTest.java
@@ -25,9 +25,9 @@
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.fail;
 
+import org.antlr.v4.runtime.CommonToken;
 import org.junit.jupiter.api.Test;
 
-import antlr.CommonHiddenStreamToken;
 import com.puppycrawl.tools.checkstyle.AbstractModuleTestSupport;
 import com.puppycrawl.tools.checkstyle.DefaultConfiguration;
 import com.puppycrawl.tools.checkstyle.DetailAstImpl;
@@ -172,7 +172,7 @@ public void testWrongToken() {
         final ClassDataAbstractionCouplingCheck classDataAbstractionCouplingCheckObj =
             new ClassDataAbstractionCouplingCheck();
         final DetailAstImpl ast = new DetailAstImpl();
-        ast.initialize(new CommonHiddenStreamToken(TokenTypes.CTOR_DEF, "ctor"));
+        ast.initialize(new CommonToken(TokenTypes.CTOR_DEF, "ctor"));
         try {
             classDataAbstractionCouplingCheckObj.visitToken(ast);
             fail("exception expected");
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/checks/metrics/NPathComplexityCheckTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/checks/metrics/NPathComplexityCheckTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/checks/metrics/NPathComplexityCheckTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/checks/metrics/NPathComplexityCheckTest.java
@@ -30,9 +30,9 @@
 import java.util.Optional;
 import java.util.SortedSet;
 
+import org.antlr.v4.runtime.CommonToken;
 import org.junit.jupiter.api.Test;
 
-import antlr.CommonHiddenStreamToken;
 import com.puppycrawl.tools.checkstyle.AbstractModuleTestSupport;
 import com.puppycrawl.tools.checkstyle.DefaultConfiguration;
 import com.puppycrawl.tools.checkstyle.DetailAstImpl;
@@ -300,7 +300,7 @@ public void testGetRequiredTokens() {
     public void testDefaultHooks() {
         final NPathComplexityCheck npathComplexityCheckObj = new NPathComplexityCheck();
         final DetailAstImpl ast = new DetailAstImpl();
-        ast.initialize(new CommonHiddenStreamToken(TokenTypes.INTERFACE_DEF, "interface"));
+        ast.initialize(new CommonToken(TokenTypes.INTERFACE_DEF, "interface"));
 
         npathComplexityCheckObj.visitToken(ast);
         final SortedSet<Violation> violations1 = npathComplexityCheckObj.getViolations();
@@ -342,18 +342,18 @@ public void testTokenEndIsAfterSameLineColumn() throws Exception {
     @Test
     public void testVisitTokenBeforeExpressionRange() {
         // Create first ast
-        final DetailAstImpl astIf = mockAST(TokenTypes.LITERAL_IF, "if", "mockfile", 2, 2);
-        final DetailAstImpl astIfLeftParen = mockAST(TokenTypes.LPAREN, "(", "mockfile", 3, 3);
+        final DetailAstImpl astIf = mockAST(TokenTypes.LITERAL_IF, "if", 2, 2);
+        final DetailAstImpl astIfLeftParen = mockAST(TokenTypes.LPAREN, "(", 3, 3);
         astIf.addChild(astIfLeftParen);
         final DetailAstImpl astIfTrue =
-                mockAST(TokenTypes.LITERAL_TRUE, "true", "mockfile", 3, 3);
+                mockAST(TokenTypes.LITERAL_TRUE, "true", 3, 3);
         astIf.addChild(astIfTrue);
-        final DetailAstImpl astIfRightParen = mockAST(TokenTypes.RPAREN, ")", "mockfile", 4, 4);
+        final DetailAstImpl astIfRightParen = mockAST(TokenTypes.RPAREN, ")", 4, 4);
         astIf.addChild(astIfRightParen);
         // Create ternary ast
-        final DetailAstImpl astTernary = mockAST(TokenTypes.QUESTION, "?", "mockfile", 1, 1);
+        final DetailAstImpl astTernary = mockAST(TokenTypes.QUESTION, "?", 1, 1);
         final DetailAstImpl astTernaryTrue =
-                mockAST(TokenTypes.LITERAL_TRUE, "true", "mockfile", 1, 2);
+                mockAST(TokenTypes.LITERAL_TRUE, "true", 1, 2);
         astTernary.addChild(astTernaryTrue);
 
         final NPathComplexityCheck npathComplexityCheckObj = new NPathComplexityCheck();
@@ -376,19 +376,15 @@ public void testVisitTokenBeforeExpressionRange() {
      *
      * @param tokenType type of token
      * @param tokenText text of token
-     * @param tokenFileName file name of token
      * @param tokenRow token position in a file (row)
      * @param tokenColumn token position in a file (column)
      * @return AST node for the token
      */
     private static DetailAstImpl mockAST(final int tokenType, final String tokenText,
-            final String tokenFileName, final int tokenRow, final int tokenColumn) {
-        final CommonHiddenStreamToken tokenImportSemi = new CommonHiddenStreamToken();
-        tokenImportSemi.setType(tokenType);
-        tokenImportSemi.setText(tokenText);
+            final int tokenRow, final int tokenColumn) {
+        final CommonToken tokenImportSemi = new CommonToken(tokenType, tokenText);
         tokenImportSemi.setLine(tokenRow);
-        tokenImportSemi.setColumn(tokenColumn);
-        tokenImportSemi.setFilename(tokenFileName);
+        tokenImportSemi.setCharPositionInLine(tokenColumn);
         final DetailAstImpl astSemi = new DetailAstImpl();
         astSemi.initialize(tokenImportSemi);
         return astSemi;
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/checks/sizes/ExecutableStatementCountCheckTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/checks/sizes/ExecutableStatementCountCheckTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/checks/sizes/ExecutableStatementCountCheckTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/checks/sizes/ExecutableStatementCountCheckTest.java
@@ -26,9 +26,9 @@
 
 import java.util.Collection;
 
+import org.antlr.v4.runtime.CommonToken;
 import org.junit.jupiter.api.Test;
 
-import antlr.CommonHiddenStreamToken;
 import com.puppycrawl.tools.checkstyle.AbstractModuleTestSupport;
 import com.puppycrawl.tools.checkstyle.DefaultConfiguration;
 import com.puppycrawl.tools.checkstyle.DetailAstImpl;
@@ -153,7 +153,7 @@ public void testVisitTokenWithWrongTokenType() {
             new ExecutableStatementCountCheck();
         final DetailAstImpl ast = new DetailAstImpl();
         ast.initialize(
-            new CommonHiddenStreamToken(TokenTypes.ENUM, "ENUM"));
+            new CommonToken(TokenTypes.ENUM, "ENUM"));
         try {
             checkObj.visitToken(ast);
             fail("exception expected");
@@ -169,7 +169,7 @@ public void testLeaveTokenWithWrongTokenType() {
             new ExecutableStatementCountCheck();
         final DetailAstImpl ast = new DetailAstImpl();
         ast.initialize(
-            new CommonHiddenStreamToken(TokenTypes.ENUM, "ENUM"));
+            new CommonToken(TokenTypes.ENUM, "ENUM"));
         try {
             checkObj.leaveToken(ast);
             fail("exception expected");
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/checks/whitespace/GenericWhitespaceCheckTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/checks/whitespace/GenericWhitespaceCheckTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/checks/whitespace/GenericWhitespaceCheckTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/checks/whitespace/GenericWhitespaceCheckTest.java
@@ -27,9 +27,9 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.fail;
 
+import org.antlr.v4.runtime.CommonToken;
 import org.junit.jupiter.api.Test;
 
-import antlr.CommonHiddenStreamToken;
 import com.puppycrawl.tools.checkstyle.AbstractModuleTestSupport;
 import com.puppycrawl.tools.checkstyle.DefaultConfiguration;
 import com.puppycrawl.tools.checkstyle.DetailAstImpl;
@@ -168,7 +168,7 @@ public void testGetAcceptableTokens() {
     public void testWrongTokenType() {
         final GenericWhitespaceCheck genericWhitespaceCheckObj = new GenericWhitespaceCheck();
         final DetailAstImpl ast = new DetailAstImpl();
-        ast.initialize(new CommonHiddenStreamToken(TokenTypes.INTERFACE_DEF, "interface"));
+        ast.initialize(new CommonToken(TokenTypes.INTERFACE_DEF, "interface"));
         try {
             genericWhitespaceCheckObj.visitToken(ast);
             fail("exception expected");
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/checks/whitespace/NoWhitespaceAfterCheckTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/checks/whitespace/NoWhitespaceAfterCheckTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/checks/whitespace/NoWhitespaceAfterCheckTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/checks/whitespace/NoWhitespaceAfterCheckTest.java
@@ -23,9 +23,9 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.fail;
 
+import org.antlr.v4.runtime.CommonToken;
 import org.junit.jupiter.api.Test;
 
-import antlr.CommonHiddenStreamToken;
 import com.puppycrawl.tools.checkstyle.AbstractModuleTestSupport;
 import com.puppycrawl.tools.checkstyle.DefaultConfiguration;
 import com.puppycrawl.tools.checkstyle.DetailAstImpl;
@@ -231,10 +231,9 @@ public void testArrayDeclarator() throws Exception {
     @Test
     public void testVisitTokenSwitchReflection() {
         // unexpected parent for ARRAY_DECLARATOR token
-        final DetailAstImpl astImport = mockAST(TokenTypes.IMPORT, "import", "mockfile");
-        final DetailAstImpl astArrayDeclarator = mockAST(TokenTypes.ARRAY_DECLARATOR, "[",
-                "mockfile");
-        final DetailAstImpl astRightBracket = mockAST(TokenTypes.RBRACK, "[", "mockfile");
+        final DetailAstImpl astImport = mockAST(TokenTypes.IMPORT, "import");
+        final DetailAstImpl astArrayDeclarator = mockAST(TokenTypes.ARRAY_DECLARATOR, "[");
+        final DetailAstImpl astRightBracket = mockAST(TokenTypes.RBRACK, "[");
         astImport.addChild(astArrayDeclarator);
         astArrayDeclarator.addChild(astRightBracket);
 
@@ -364,17 +363,11 @@ public void testArrayNewGenericTypeArgument() throws Exception {
      *
      * @param tokenType type of token
      * @param tokenText text of token
-     * @param tokenFileName file name of token
      * @return AST node for the token
      */
-    private static DetailAstImpl mockAST(final int tokenType, final String tokenText,
-            final String tokenFileName) {
-        final CommonHiddenStreamToken tokenImportSemi = new CommonHiddenStreamToken();
-        tokenImportSemi.setType(tokenType);
-        tokenImportSemi.setText(tokenText);
-        tokenImportSemi.setFilename(tokenFileName);
+    private static DetailAstImpl mockAST(final int tokenType, final String tokenText) {
         final DetailAstImpl astSemi = new DetailAstImpl();
-        astSemi.initialize(tokenImportSemi);
+        astSemi.initialize(new CommonToken(tokenType, tokenText));
         return astSemi;
     }
 
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/checks/whitespace/WhitespaceAfterCheckTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/checks/whitespace/WhitespaceAfterCheckTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/checks/whitespace/WhitespaceAfterCheckTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/checks/whitespace/WhitespaceAfterCheckTest.java
@@ -196,4 +196,12 @@ public void test1322879() throws Exception {
                expected);
     }
 
+    @Test
+    public void testCountUnicodeCorrectly() throws Exception {
+        final DefaultConfiguration checkConfig = createModuleConfig(WhitespaceAfterCheck.class);
+        final String[] expected = {
+            "9:20: " + getCheckMessage(MSG_WS_NOT_FOLLOWED, ";"),
+        };
+        verify(checkConfig, getPath("InputWhitespaceAfterCountUnicodeCorrectly.java"), expected);
+    }
 }
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/grammar/AstRegressionTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/grammar/AstRegressionTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/grammar/AstRegressionTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/grammar/AstRegressionTest.java
@@ -20,25 +20,13 @@
 package com.puppycrawl.tools.checkstyle.grammar;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.io.File;
-import java.io.InputStream;
-import java.io.Reader;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 
 import org.junit.jupiter.api.Test;
 
-import antlr.NoViableAltForCharException;
-import antlr.ParserSharedInputState;
-import antlr.SemanticException;
-import antlr.TokenBuffer;
 import com.puppycrawl.tools.checkstyle.AbstractTreeTestSupport;
 import com.puppycrawl.tools.checkstyle.AstTreeStringPrinter;
 import com.puppycrawl.tools.checkstyle.JavaParser;
@@ -147,43 +135,6 @@ public void testCharLiteralSurrogatePair() throws Exception {
                 getPath("InputCharLiteralSurrogatePair.java"));
     }
 
-    @Test
-    public void testUnusedConstructors1() throws Exception {
-        final Class<?> clss = GeneratedJavaLexer.class;
-        final Constructor<?> constructor = clss.getDeclaredConstructor(InputStream.class);
-
-        assertNotNull(constructor.newInstance(new Object[] {null}),
-                "InputStream should not be null");
-    }
-
-    @Test
-    public void testUnusedConstructors2() throws Exception {
-        final Class<?> clss = GeneratedJavaRecognizer.class;
-        final Constructor<?> constructor = clss
-                .getDeclaredConstructor(ParserSharedInputState.class);
-
-        assertNotNull(constructor.newInstance(new Object[] {null}),
-                "ParserSharedInputState should not be null");
-    }
-
-    @Test
-    public void testUnusedConstructors3() throws Exception {
-        final Class<?> clss = GeneratedJavaRecognizer.class;
-        final Constructor<?> constructor = clss.getDeclaredConstructor(TokenBuffer.class);
-
-        assertNotNull(constructor.newInstance(new Object[] {null}),
-                "TokenBuffer should not be null");
-    }
-
-    @Test
-    public void testUnusedConstructors4() throws Exception {
-        final Class<?> clss = GeneratedTextBlockLexer.class;
-        final Constructor<?> constructor = clss.getDeclaredConstructor(Reader.class);
-
-        assertNotNull(constructor.newInstance(new Object[] {null}),
-                "Reader should not be null");
-    }
-
     @Test
     public void testCustomAstTree() throws Exception {
         verifyAstRaw(getPath("InputRegressionEmptyAst.txt"), "\t");
@@ -303,79 +254,6 @@ public void testInputManyAlternativesInMultiCatch() throws Exception {
                 getPath("InputAstRegressionManyAlternativesInMultiCatch.java"));
     }
 
-    @Test
-    public void testImpossibleExceptions() throws Exception {
-        AssertGeneratedJavaLexer.verifyFail("mSTD_ESC", 'a');
-        AssertGeneratedJavaLexer.verifyFail("mSTD_ESC", '0', (char) 0xFFFF);
-        AssertGeneratedJavaLexer.verifyFail("mSTD_ESC", '4', (char) 0xFFFF);
-        AssertGeneratedJavaLexer.verifyFail("mCHAR_LITERAL", '\'', '\'');
-        AssertGeneratedJavaLexer.verifyFail("mHEX_DIGIT", ';');
-        AssertGeneratedJavaLexer.verifyFail("mEXPONENT", ';');
-        AssertGeneratedJavaLexer.verifyFail("mBINARY_DIGIT", '2');
-        AssertGeneratedJavaLexer.verifyFail("mSIGNED_INTEGER", 'a');
-        AssertGeneratedJavaLexer.verifyFail("mID_START", '%');
-        AssertGeneratedJavaLexer.verifyFail("mID_START", (char) 0xBF);
-        AssertGeneratedJavaLexer.verifyFailNoGuessing("mID_START", (char) 0xBF);
-        AssertGeneratedJavaLexer.verifyFail("mID_PART", '%');
-        AssertGeneratedJavaLexer.verifyFail("mID_PART", (char) 0xBF);
-        AssertGeneratedJavaLexer.verifyFailNoGuessing("mID_PART", (char) 0xBF);
-        AssertGeneratedJavaLexer.verifyFail("mESC", '\\', 'a');
-        AssertGeneratedJavaLexer.verifyFail("mLONG_LITERAL", '0', ';');
-        AssertGeneratedJavaLexer.verifyFail("mLONG_LITERAL", '1', ';');
-        AssertGeneratedJavaLexer.verifyFail("mLONG_LITERAL", ';');
-        AssertGeneratedJavaLexer.verifyFail("mINT_LITERAL", ';');
-        AssertGeneratedJavaLexer.verifyFail("mHEX_DOUBLE_LITERAL", '0', 'a');
-        AssertGeneratedJavaLexer.verifyFail("mHEX_FLOAT_LITERAL", '0', 'a');
-    }
-
-    @Test
-    public void testImpossibleValid() throws Exception {
-        AssertGeneratedJavaLexer.verifyPass("mSTD_ESC", 'n');
-        AssertGeneratedJavaLexer.verifyPass("mELLIPSIS", '.', '.', '.');
-        AssertGeneratedJavaLexer.verifyPass("mDOT", '.');
-        AssertGeneratedJavaLexer.verifyPass("mBINARY_EXPONENT", 'p', '0', ';');
-        AssertGeneratedJavaLexer.verifyPass("mHEX_DIGIT", '0');
-        AssertGeneratedJavaLexer.verifyPass("mEXPONENT", 'e', '0', ';');
-        AssertGeneratedJavaLexer.verifyPass("mBINARY_DIGIT", '0');
-        AssertGeneratedJavaLexer.verifyPass("mSIGNED_INTEGER", '0', ';');
-        AssertGeneratedJavaLexer.verifyPass("mWS", ' ', ';');
-        AssertGeneratedJavaLexer.verifyPass("mID_START", '$');
-        AssertGeneratedJavaLexer.verifyPass("mID_PART", '$');
-        AssertGeneratedJavaLexer.verifyPass("mESC", '\\', '\\');
-        AssertGeneratedJavaLexer.verifyPass("mLONG_LITERAL", '1', 'L');
-        AssertGeneratedJavaLexer.verifyPass("mINT_LITERAL", '0', ';');
-        AssertGeneratedJavaLexer.verifyPass("mFLOAT_LITERAL", '0', 'f');
-        AssertGeneratedJavaLexer.verifyPass("mDOUBLE_LITERAL", '0', 'd');
-        AssertGeneratedJavaLexer.verifyPass("mHEX_FLOAT_LITERAL", '0', 'x', '2', '_', '4', '.',
-                '4', '4', '.', '4', 'P', '4', ';');
-        AssertGeneratedJavaLexer.verifyPass("mHEX_DOUBLE_LITERAL", '0', 'x', '2', '_', '4', '.',
-                '4', '4', '.', '4', 'P', '4', 'D', ';');
-    }
-
-    @Test
-    public void testImpossibleExceptionsTextBlockLexer() throws Exception {
-        AssertGenTextBlockLexer.verifyFail("mSTD_ESC", '\\', '*', (char) 0xFFFF);
-        AssertGenTextBlockLexer.verifyFail("mONE_DOUBLE_QUOTE", '"', '"');
-        AssertGenTextBlockLexer.verifyFail("mNEWLINE", '*');
-        AssertGenTextBlockLexer.verifyFail("mTEXT_BLOCK_CONTENT", (char) 0xFFFF);
-    }
-
-    @Test
-    public void testImpossibleValidTextBlockLexer() throws Exception {
-        AssertGenTextBlockLexer.verifyPass("mSTD_ESC", '\\', '\\', 'n');
-        AssertGenTextBlockLexer.verifyPass("mNEWLINE", '\r', '\n');
-        AssertGenTextBlockLexer.verifyPass("mNEWLINE", '\r', '1');
-        AssertGenTextBlockLexer.verifyPass("mTEXT_BLOCK_CONTENT", '\\', (char) 0xFFFF);
-        AssertGenTextBlockLexer.verifyPass("mTEXT_BLOCK_CONTENT", '\r', (char) 0xFFFF);
-        AssertGenTextBlockLexer.verifyPass("mONE_DOUBLE_QUOTE", '"', 'a');
-        AssertGenTextBlockLexer.verifyPass("mTWO_DOUBLE_QUOTES", '"', '"', 'a');
-        AssertGenTextBlockLexer.verifyPass("mONE_DOUBLE_QUOTE", '"', '\r', '\r');
-        AssertGenTextBlockLexer
-                .verifyPass("mTWO_DOUBLE_QUOTES", '"', '"', '\r', '\r');
-        AssertGenTextBlockLexer
-                .verifyPass("mTEXT_BLOCK_LITERAL_END", '"', '"', '"', (char) 0xFFFF);
-    }
-
     private static void verifyAstRaw(String expectedTextPrintFileName, String actualJava)
             throws Exception {
         verifyAstRaw(expectedTextPrintFileName, actualJava, JavaParser.Options.WITHOUT_COMMENTS);
@@ -396,156 +274,4 @@ private static void verifyAstRaw(String expectedTextPrintFileName, String actual
         assertEquals(expectedContents, actualContents,
                 "Generated AST from Java code should match pre-defined AST");
     }
-
-    private static final class AssertGenTextBlockLexer
-            extends GeneratedTextBlockLexer {
-
-        private int laPosition;
-        private char[] laResults;
-
-        private AssertGenTextBlockLexer() {
-            super((InputStream) null);
-        }
-
-        public static void verifyPass(String methodName, char... laResults) throws Exception {
-            verify(methodName, true, 1, laResults);
-        }
-
-        public static void verifyFail(String methodName, char... laResults) throws Exception {
-            verify(methodName, false, 1, laResults);
-        }
-
-        private static void verify(String methodName, boolean expectPass, int guessing,
-                                   char... laResults) throws Exception {
-            final AssertGenTextBlockLexer instance =
-                    new AssertGenTextBlockLexer();
-            instance.laPosition = 0;
-            instance.laResults = laResults.clone();
-            instance.inputState.guessing = guessing;
-
-            final Method method = GeneratedTextBlockLexer.class.getDeclaredMethod(methodName,
-                    boolean.class);
-            boolean exception;
-
-            try {
-                method.invoke(instance, true);
-                exception = false;
-            }
-            catch (InvocationTargetException ex) {
-                if (expectPass) {
-                    throw ex;
-                }
-
-                final Class<?> clss = ex.getTargetException().getClass();
-                if (clss != NoViableAltForCharException.class
-                        && clss != SemanticException.class) {
-                    throw ex;
-                }
-                exception = true;
-            }
-
-            if (expectPass) {
-                assertFalse(exception, "Call to GeneratedTextBlockLexer." + methodName
-                        + " resulted in an exception");
-            }
-            else {
-                assertTrue(exception, "Call to GeneratedTextBlockLexer." + methodName
-                        + " did not result in an exception");
-            }
-        }
-
-        @Override
-        public char LA(int i) {
-            return laResults[laPosition + i - 1];
-        }
-
-        @Override
-        public void consume() {
-            laPosition++;
-        }
-
-        @Override
-        public int mark() {
-            return 1;
-        }
-
-    }
-
-    private static final class AssertGeneratedJavaLexer extends GeneratedJavaLexer {
-
-        private int laPosition;
-        private char[] laResults;
-
-        private AssertGeneratedJavaLexer() {
-            super((InputStream) null);
-        }
-
-        public static void verifyFailNoGuessing(String methodName, char... laResults)
-                throws Exception {
-            verify(methodName, false, 0, laResults);
-        }
-
-        public static void verifyPass(String methodName, char... laResults) throws Exception {
-            verify(methodName, true, 1, laResults);
-        }
-
-        public static void verifyFail(String methodName, char... laResults) throws Exception {
-            verify(methodName, false, 1, laResults);
-        }
-
-        private static void verify(String methodName, boolean expectPass, int guessing,
-                char... laResults) throws Exception {
-            final AssertGeneratedJavaLexer instance = new AssertGeneratedJavaLexer();
-            instance.laPosition = 0;
-            instance.laResults = laResults.clone();
-            instance.inputState.guessing = guessing;
-
-            final Method method = GeneratedJavaLexer.class.getDeclaredMethod(methodName,
-                    boolean.class);
-            boolean exception;
-
-            try {
-                method.invoke(instance, true);
-                exception = false;
-            }
-            catch (InvocationTargetException ex) {
-                if (expectPass) {
-                    throw ex;
-                }
-
-                final Class<?> clss = ex.getTargetException().getClass();
-                if (clss != NoViableAltForCharException.class
-                        && clss != SemanticException.class) {
-                    throw ex;
-                }
-                exception = true;
-            }
-
-            if (expectPass) {
-                assertFalse(exception, "Call to GeneratedJavaLexer." + methodName
-                        + " resulted in an exception");
-            }
-            else {
-                assertTrue(exception, "Call to GeneratedJavaLexer." + methodName
-                        + " did not result in an exception");
-            }
-        }
-
-        @Override
-        public char LA(int i) {
-            return laResults[laPosition + i - 1];
-        }
-
-        @Override
-        public void consume() {
-            laPosition++;
-        }
-
-        @Override
-        public int mark() {
-            return 1;
-        }
-
-    }
-
 }
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/grammar/GeneratedJavaTokenTypesTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/grammar/GeneratedJavaTokenTypesTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/grammar/GeneratedJavaTokenTypesTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/grammar/GeneratedJavaTokenTypesTest.java
@@ -21,8 +21,15 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+
+import org.antlr.v4.runtime.Recognizer;
 import org.junit.jupiter.api.Test;
 
+import com.puppycrawl.tools.checkstyle.grammar.java.JavaLexer;
+
 /**
  * GeneratedJavaTokenTypesTest.
  *
@@ -40,7 +47,7 @@ public class GeneratedJavaTokenTypesTest {
      * <p>
      * The reason behind this is Java inlines static final field values directly
      * into the compiled Java code. This loses all connections with the original
-     * class, GeneratedJavaTokenTypes, and so numbering updates are not picked
+     * class, JavaLexer, and so numbering updates are not picked
      * up in user-created checks and causes conflicts.
      * </p>
      *
@@ -57,223 +64,241 @@ public void testTokenNumbering() {
                 + "See Issue: https://github.com/checkstyle/checkstyle/issues/505";
 
         // Read JavaDoc before changing
-        assertEquals(1, GeneratedJavaTokenTypes.EOF, message);
-        assertEquals(3, GeneratedJavaTokenTypes.NULL_TREE_LOOKAHEAD, message);
-        assertEquals(4, GeneratedJavaTokenTypes.BLOCK, message);
-        assertEquals(5, GeneratedJavaTokenTypes.MODIFIERS, message);
-        assertEquals(6, GeneratedJavaTokenTypes.OBJBLOCK, message);
-        assertEquals(7, GeneratedJavaTokenTypes.SLIST, message);
-        assertEquals(8, GeneratedJavaTokenTypes.CTOR_DEF, message);
-        assertEquals(9, GeneratedJavaTokenTypes.METHOD_DEF, message);
-        assertEquals(10, GeneratedJavaTokenTypes.VARIABLE_DEF, message);
-        assertEquals(11, GeneratedJavaTokenTypes.INSTANCE_INIT, message);
-        assertEquals(12, GeneratedJavaTokenTypes.STATIC_INIT, message);
-        assertEquals(13, GeneratedJavaTokenTypes.TYPE, message);
-        assertEquals(14, GeneratedJavaTokenTypes.CLASS_DEF, message);
-        assertEquals(15, GeneratedJavaTokenTypes.INTERFACE_DEF, message);
-        assertEquals(16, GeneratedJavaTokenTypes.PACKAGE_DEF, message);
-        assertEquals(17, GeneratedJavaTokenTypes.ARRAY_DECLARATOR, message);
-        assertEquals(18, GeneratedJavaTokenTypes.EXTENDS_CLAUSE, message);
-        assertEquals(19, GeneratedJavaTokenTypes.IMPLEMENTS_CLAUSE, message);
-        assertEquals(20, GeneratedJavaTokenTypes.PARAMETERS, message);
-        assertEquals(21, GeneratedJavaTokenTypes.PARAMETER_DEF, message);
-        assertEquals(22, GeneratedJavaTokenTypes.LABELED_STAT, message);
-        assertEquals(23, GeneratedJavaTokenTypes.TYPECAST, message);
-        assertEquals(24, GeneratedJavaTokenTypes.INDEX_OP, message);
-        assertEquals(25, GeneratedJavaTokenTypes.POST_INC, message);
-        assertEquals(26, GeneratedJavaTokenTypes.POST_DEC, message);
-        assertEquals(27, GeneratedJavaTokenTypes.METHOD_CALL, message);
-        assertEquals(28, GeneratedJavaTokenTypes.EXPR, message);
-        assertEquals(29, GeneratedJavaTokenTypes.ARRAY_INIT, message);
-        assertEquals(30, GeneratedJavaTokenTypes.IMPORT, message);
-        assertEquals(31, GeneratedJavaTokenTypes.UNARY_MINUS, message);
-        assertEquals(32, GeneratedJavaTokenTypes.UNARY_PLUS, message);
-        assertEquals(33, GeneratedJavaTokenTypes.CASE_GROUP, message);
-        assertEquals(34, GeneratedJavaTokenTypes.ELIST, message);
-        assertEquals(35, GeneratedJavaTokenTypes.FOR_INIT, message);
-        assertEquals(36, GeneratedJavaTokenTypes.FOR_CONDITION, message);
-        assertEquals(37, GeneratedJavaTokenTypes.FOR_ITERATOR, message);
-        assertEquals(38, GeneratedJavaTokenTypes.EMPTY_STAT, message);
-        assertEquals(39, GeneratedJavaTokenTypes.FINAL, message);
-        assertEquals(40, GeneratedJavaTokenTypes.ABSTRACT, message);
-        assertEquals(41, GeneratedJavaTokenTypes.STRICTFP, message);
-        assertEquals(42, GeneratedJavaTokenTypes.SUPER_CTOR_CALL, message);
-        assertEquals(43, GeneratedJavaTokenTypes.CTOR_CALL, message);
-        assertEquals(44, GeneratedJavaTokenTypes.LITERAL_package, message);
-        assertEquals(45, GeneratedJavaTokenTypes.SEMI, message);
-        assertEquals(46, GeneratedJavaTokenTypes.LITERAL_import, message);
-        assertEquals(47, GeneratedJavaTokenTypes.LBRACK, message);
-        assertEquals(48, GeneratedJavaTokenTypes.RBRACK, message);
-        assertEquals(49, GeneratedJavaTokenTypes.LITERAL_void, message);
-        assertEquals(50, GeneratedJavaTokenTypes.LITERAL_boolean, message);
-        assertEquals(51, GeneratedJavaTokenTypes.LITERAL_byte, message);
-        assertEquals(52, GeneratedJavaTokenTypes.LITERAL_char, message);
-        assertEquals(53, GeneratedJavaTokenTypes.LITERAL_short, message);
-        assertEquals(54, GeneratedJavaTokenTypes.LITERAL_int, message);
-        assertEquals(55, GeneratedJavaTokenTypes.LITERAL_float, message);
-        assertEquals(56, GeneratedJavaTokenTypes.LITERAL_long, message);
-        assertEquals(57, GeneratedJavaTokenTypes.LITERAL_double, message);
-        assertEquals(58, GeneratedJavaTokenTypes.IDENT, message);
-        assertEquals(59, GeneratedJavaTokenTypes.DOT, message);
-        assertEquals(60, GeneratedJavaTokenTypes.STAR, message);
-        assertEquals(61, GeneratedJavaTokenTypes.LITERAL_private, message);
-        assertEquals(62, GeneratedJavaTokenTypes.LITERAL_public, message);
-        assertEquals(63, GeneratedJavaTokenTypes.LITERAL_protected, message);
-        assertEquals(64, GeneratedJavaTokenTypes.LITERAL_static, message);
-        assertEquals(65, GeneratedJavaTokenTypes.LITERAL_transient, message);
-        assertEquals(66, GeneratedJavaTokenTypes.LITERAL_native, message);
-        assertEquals(67, GeneratedJavaTokenTypes.LITERAL_synchronized, message);
-        assertEquals(68, GeneratedJavaTokenTypes.LITERAL_volatile, message);
-        assertEquals(69, GeneratedJavaTokenTypes.LITERAL_class, message);
-        assertEquals(70, GeneratedJavaTokenTypes.LITERAL_extends, message);
-        assertEquals(71, GeneratedJavaTokenTypes.LITERAL_interface, message);
-        assertEquals(72, GeneratedJavaTokenTypes.LCURLY, message);
-        assertEquals(73, GeneratedJavaTokenTypes.RCURLY, message);
-        assertEquals(74, GeneratedJavaTokenTypes.COMMA, message);
-        assertEquals(75, GeneratedJavaTokenTypes.LITERAL_implements, message);
-        assertEquals(76, GeneratedJavaTokenTypes.LPAREN, message);
-        assertEquals(77, GeneratedJavaTokenTypes.RPAREN, message);
-        assertEquals(78, GeneratedJavaTokenTypes.LITERAL_this, message);
-        assertEquals(79, GeneratedJavaTokenTypes.LITERAL_super, message);
-        assertEquals(80, GeneratedJavaTokenTypes.ASSIGN, message);
-        assertEquals(81, GeneratedJavaTokenTypes.LITERAL_throws, message);
-        assertEquals(82, GeneratedJavaTokenTypes.COLON, message);
-        assertEquals(83, GeneratedJavaTokenTypes.LITERAL_if, message);
-        assertEquals(84, GeneratedJavaTokenTypes.LITERAL_while, message);
-        assertEquals(85, GeneratedJavaTokenTypes.LITERAL_do, message);
-        assertEquals(86, GeneratedJavaTokenTypes.LITERAL_break, message);
-        assertEquals(87, GeneratedJavaTokenTypes.LITERAL_continue, message);
-        assertEquals(88, GeneratedJavaTokenTypes.LITERAL_return, message);
-        assertEquals(89, GeneratedJavaTokenTypes.LITERAL_switch, message);
-        assertEquals(90, GeneratedJavaTokenTypes.LITERAL_throw, message);
-        assertEquals(91, GeneratedJavaTokenTypes.LITERAL_for, message);
-        assertEquals(92, GeneratedJavaTokenTypes.LITERAL_else, message);
-        assertEquals(93, GeneratedJavaTokenTypes.LITERAL_case, message);
-        assertEquals(94, GeneratedJavaTokenTypes.LITERAL_default, message);
-        assertEquals(95, GeneratedJavaTokenTypes.LITERAL_try, message);
-        assertEquals(96, GeneratedJavaTokenTypes.LITERAL_catch, message);
-        assertEquals(97, GeneratedJavaTokenTypes.LITERAL_finally, message);
-        assertEquals(98, GeneratedJavaTokenTypes.PLUS_ASSIGN, message);
-        assertEquals(99, GeneratedJavaTokenTypes.MINUS_ASSIGN, message);
-        assertEquals(100, GeneratedJavaTokenTypes.STAR_ASSIGN, message);
-        assertEquals(101, GeneratedJavaTokenTypes.DIV_ASSIGN, message);
-        assertEquals(102, GeneratedJavaTokenTypes.MOD_ASSIGN, message);
-        assertEquals(103, GeneratedJavaTokenTypes.SR_ASSIGN, message);
-        assertEquals(104, GeneratedJavaTokenTypes.BSR_ASSIGN, message);
-        assertEquals(105, GeneratedJavaTokenTypes.SL_ASSIGN, message);
-        assertEquals(106, GeneratedJavaTokenTypes.BAND_ASSIGN, message);
-        assertEquals(107, GeneratedJavaTokenTypes.BXOR_ASSIGN, message);
-        assertEquals(108, GeneratedJavaTokenTypes.BOR_ASSIGN, message);
-        assertEquals(109, GeneratedJavaTokenTypes.QUESTION, message);
-        assertEquals(110, GeneratedJavaTokenTypes.LOR, message);
-        assertEquals(111, GeneratedJavaTokenTypes.LAND, message);
-        assertEquals(112, GeneratedJavaTokenTypes.BOR, message);
-        assertEquals(113, GeneratedJavaTokenTypes.BXOR, message);
-        assertEquals(114, GeneratedJavaTokenTypes.BAND, message);
-        assertEquals(115, GeneratedJavaTokenTypes.NOT_EQUAL, message);
-        assertEquals(116, GeneratedJavaTokenTypes.EQUAL, message);
-        assertEquals(117, GeneratedJavaTokenTypes.LT, message);
-        assertEquals(118, GeneratedJavaTokenTypes.GT, message);
-        assertEquals(119, GeneratedJavaTokenTypes.LE, message);
-        assertEquals(120, GeneratedJavaTokenTypes.GE, message);
-        assertEquals(121, GeneratedJavaTokenTypes.LITERAL_instanceof, message);
-        assertEquals(122, GeneratedJavaTokenTypes.SL, message);
-        assertEquals(123, GeneratedJavaTokenTypes.SR, message);
-        assertEquals(124, GeneratedJavaTokenTypes.BSR, message);
-        assertEquals(125, GeneratedJavaTokenTypes.PLUS, message);
-        assertEquals(126, GeneratedJavaTokenTypes.MINUS, message);
-        assertEquals(127, GeneratedJavaTokenTypes.DIV, message);
-        assertEquals(128, GeneratedJavaTokenTypes.MOD, message);
-        assertEquals(129, GeneratedJavaTokenTypes.INC, message);
-        assertEquals(130, GeneratedJavaTokenTypes.DEC, message);
-        assertEquals(131, GeneratedJavaTokenTypes.BNOT, message);
-        assertEquals(132, GeneratedJavaTokenTypes.LNOT, message);
-        assertEquals(133, GeneratedJavaTokenTypes.LITERAL_true, message);
-        assertEquals(134, GeneratedJavaTokenTypes.LITERAL_false, message);
-        assertEquals(135, GeneratedJavaTokenTypes.LITERAL_null, message);
-        assertEquals(136, GeneratedJavaTokenTypes.LITERAL_new, message);
-        assertEquals(137, GeneratedJavaTokenTypes.NUM_INT, message);
-        assertEquals(138, GeneratedJavaTokenTypes.CHAR_LITERAL, message);
-        assertEquals(139, GeneratedJavaTokenTypes.STRING_LITERAL, message);
-        assertEquals(140, GeneratedJavaTokenTypes.NUM_FLOAT, message);
-        assertEquals(141, GeneratedJavaTokenTypes.NUM_LONG, message);
-        assertEquals(142, GeneratedJavaTokenTypes.NUM_DOUBLE, message);
-        assertEquals(143, GeneratedJavaTokenTypes.WS, message);
-        assertEquals(144, GeneratedJavaTokenTypes.SINGLE_LINE_COMMENT, message);
-        assertEquals(145, GeneratedJavaTokenTypes.BLOCK_COMMENT_BEGIN, message);
-        assertEquals(146, GeneratedJavaTokenTypes.ESC, message);
-        assertEquals(147, GeneratedJavaTokenTypes.HEX_DIGIT, message);
-        assertEquals(148, GeneratedJavaTokenTypes.VOCAB, message);
-        assertEquals(149, GeneratedJavaTokenTypes.EXPONENT, message);
-        assertEquals(150, GeneratedJavaTokenTypes.FLOAT_SUFFIX, message);
-        assertEquals(151, GeneratedJavaTokenTypes.ASSERT, message);
-        assertEquals(152, GeneratedJavaTokenTypes.STATIC_IMPORT, message);
-        assertEquals(153, GeneratedJavaTokenTypes.ENUM, message);
-        assertEquals(154, GeneratedJavaTokenTypes.ENUM_DEF, message);
-        assertEquals(155, GeneratedJavaTokenTypes.ENUM_CONSTANT_DEF, message);
-        assertEquals(156, GeneratedJavaTokenTypes.FOR_EACH_CLAUSE, message);
-        assertEquals(157, GeneratedJavaTokenTypes.ANNOTATION_DEF, message);
-        assertEquals(158, GeneratedJavaTokenTypes.ANNOTATIONS, message);
-        assertEquals(159, GeneratedJavaTokenTypes.ANNOTATION, message);
-        assertEquals(160, GeneratedJavaTokenTypes.ANNOTATION_MEMBER_VALUE_PAIR, message);
-        assertEquals(161, GeneratedJavaTokenTypes.ANNOTATION_FIELD_DEF, message);
-        assertEquals(162, GeneratedJavaTokenTypes.ANNOTATION_ARRAY_INIT, message);
-        assertEquals(163, GeneratedJavaTokenTypes.TYPE_ARGUMENTS, message);
-        assertEquals(164, GeneratedJavaTokenTypes.TYPE_ARGUMENT, message);
-        assertEquals(165, GeneratedJavaTokenTypes.TYPE_PARAMETERS, message);
-        assertEquals(166, GeneratedJavaTokenTypes.TYPE_PARAMETER, message);
-        assertEquals(167, GeneratedJavaTokenTypes.WILDCARD_TYPE, message);
-        assertEquals(168, GeneratedJavaTokenTypes.TYPE_UPPER_BOUNDS, message);
-        assertEquals(169, GeneratedJavaTokenTypes.TYPE_LOWER_BOUNDS, message);
-        assertEquals(170, GeneratedJavaTokenTypes.AT, message);
-        assertEquals(171, GeneratedJavaTokenTypes.ELLIPSIS, message);
-        assertEquals(172, GeneratedJavaTokenTypes.GENERIC_START, message);
-        assertEquals(173, GeneratedJavaTokenTypes.GENERIC_END, message);
-        assertEquals(174, GeneratedJavaTokenTypes.TYPE_EXTENSION_AND, message);
-        assertEquals(175, GeneratedJavaTokenTypes.DO_WHILE, message);
-        assertEquals(176, GeneratedJavaTokenTypes.RESOURCE_SPECIFICATION, message);
-        assertEquals(177, GeneratedJavaTokenTypes.RESOURCES, message);
-        assertEquals(178, GeneratedJavaTokenTypes.RESOURCE, message);
-        assertEquals(179, GeneratedJavaTokenTypes.DOUBLE_COLON, message);
-        assertEquals(180, GeneratedJavaTokenTypes.METHOD_REF, message);
-        assertEquals(181, GeneratedJavaTokenTypes.LAMBDA, message);
-        assertEquals(182, GeneratedJavaTokenTypes.BLOCK_COMMENT_END, message);
-        assertEquals(183, GeneratedJavaTokenTypes.COMMENT_CONTENT, message);
-        assertEquals(184, GeneratedJavaTokenTypes.SINGLE_LINE_COMMENT_CONTENT, message);
-        assertEquals(185, GeneratedJavaTokenTypes.BLOCK_COMMENT_CONTENT, message);
-        assertEquals(186, GeneratedJavaTokenTypes.STD_ESC, message);
-        assertEquals(187, GeneratedJavaTokenTypes.BINARY_DIGIT, message);
-        assertEquals(188, GeneratedJavaTokenTypes.ID_START, message);
-        assertEquals(189, GeneratedJavaTokenTypes.ID_PART, message);
-        assertEquals(190, GeneratedJavaTokenTypes.INT_LITERAL, message);
-        assertEquals(191, GeneratedJavaTokenTypes.LONG_LITERAL, message);
-        assertEquals(192, GeneratedJavaTokenTypes.FLOAT_LITERAL, message);
-        assertEquals(193, GeneratedJavaTokenTypes.DOUBLE_LITERAL, message);
-        assertEquals(194, GeneratedJavaTokenTypes.HEX_FLOAT_LITERAL, message);
-        assertEquals(195, GeneratedJavaTokenTypes.HEX_DOUBLE_LITERAL, message);
-        assertEquals(196, GeneratedJavaTokenTypes.SIGNED_INTEGER, message);
-        assertEquals(197, GeneratedJavaTokenTypes.BINARY_EXPONENT, message);
-        assertEquals(198, GeneratedJavaTokenTypes.PATTERN_VARIABLE_DEF, message);
-        assertEquals(199, GeneratedJavaTokenTypes.RECORD_DEF, message);
-        assertEquals(200, GeneratedJavaTokenTypes.LITERAL_record, message);
-        assertEquals(201, GeneratedJavaTokenTypes.RECORD_COMPONENTS, message);
-        assertEquals(202, GeneratedJavaTokenTypes.RECORD_COMPONENT_DEF, message);
-        assertEquals(203, GeneratedJavaTokenTypes.COMPACT_CTOR_DEF, message);
-        assertEquals(204, GeneratedJavaTokenTypes.TEXT_BLOCK_LITERAL_BEGIN, message);
-        assertEquals(205, GeneratedJavaTokenTypes.TEXT_BLOCK_CONTENT, message);
-        assertEquals(206, GeneratedJavaTokenTypes.TEXT_BLOCK_LITERAL_END, message);
-        assertEquals(207, GeneratedJavaTokenTypes.LITERAL_yield, message);
-        assertEquals(208, GeneratedJavaTokenTypes.SWITCH_RULE, message);
-        assertEquals(209, GeneratedJavaTokenTypes.LITERAL_non_sealed, message);
-        assertEquals(210, GeneratedJavaTokenTypes.LITERAL_sealed, message);
-        assertEquals(211, GeneratedJavaTokenTypes.LITERAL_permits, message);
-        assertEquals(212, GeneratedJavaTokenTypes.PERMITS_CLAUSE, message);
+        assertEquals(-1, Recognizer.EOF, message);
+        assertEquals(3, JavaLexer.NULL_TREE_LOOKAHEAD, message);
+        assertEquals(4, JavaLexer.BLOCK, message);
+        assertEquals(5, JavaLexer.MODIFIERS, message);
+        assertEquals(6, JavaLexer.OBJBLOCK, message);
+        assertEquals(7, JavaLexer.SLIST, message);
+        assertEquals(8, JavaLexer.CTOR_DEF, message);
+        assertEquals(9, JavaLexer.METHOD_DEF, message);
+        assertEquals(10, JavaLexer.VARIABLE_DEF, message);
+        assertEquals(11, JavaLexer.INSTANCE_INIT, message);
+        assertEquals(12, JavaLexer.STATIC_INIT, message);
+        assertEquals(13, JavaLexer.TYPE, message);
+        assertEquals(14, JavaLexer.CLASS_DEF, message);
+        assertEquals(15, JavaLexer.INTERFACE_DEF, message);
+        assertEquals(16, JavaLexer.PACKAGE_DEF, message);
+        assertEquals(17, JavaLexer.ARRAY_DECLARATOR, message);
+        assertEquals(18, JavaLexer.EXTENDS_CLAUSE, message);
+        assertEquals(19, JavaLexer.IMPLEMENTS_CLAUSE, message);
+        assertEquals(20, JavaLexer.PARAMETERS, message);
+        assertEquals(21, JavaLexer.PARAMETER_DEF, message);
+        assertEquals(22, JavaLexer.LABELED_STAT, message);
+        assertEquals(23, JavaLexer.TYPECAST, message);
+        assertEquals(24, JavaLexer.INDEX_OP, message);
+        assertEquals(25, JavaLexer.POST_INC, message);
+        assertEquals(26, JavaLexer.POST_DEC, message);
+        assertEquals(27, JavaLexer.METHOD_CALL, message);
+        assertEquals(28, JavaLexer.EXPR, message);
+        assertEquals(29, JavaLexer.ARRAY_INIT, message);
+        assertEquals(30, JavaLexer.IMPORT, message);
+        assertEquals(31, JavaLexer.UNARY_MINUS, message);
+        assertEquals(32, JavaLexer.UNARY_PLUS, message);
+        assertEquals(33, JavaLexer.CASE_GROUP, message);
+        assertEquals(34, JavaLexer.ELIST, message);
+        assertEquals(35, JavaLexer.FOR_INIT, message);
+        assertEquals(36, JavaLexer.FOR_CONDITION, message);
+        assertEquals(37, JavaLexer.FOR_ITERATOR, message);
+        assertEquals(38, JavaLexer.EMPTY_STAT, message);
+        assertEquals(39, JavaLexer.FINAL, message);
+        assertEquals(40, JavaLexer.ABSTRACT, message);
+        assertEquals(41, JavaLexer.STRICTFP, message);
+        assertEquals(42, JavaLexer.SUPER_CTOR_CALL, message);
+        assertEquals(43, JavaLexer.CTOR_CALL, message);
+        assertEquals(44, JavaLexer.LITERAL_PACKAGE, message);
+        assertEquals(45, JavaLexer.SEMI, message);
+        assertEquals(46, JavaLexer.LITERAL_IMPORT, message);
+        assertEquals(47, JavaLexer.LBRACK, message);
+        assertEquals(48, JavaLexer.RBRACK, message);
+        assertEquals(49, JavaLexer.LITERAL_VOID, message);
+        assertEquals(50, JavaLexer.LITERAL_BOOLEAN, message);
+        assertEquals(51, JavaLexer.LITERAL_BYTE, message);
+        assertEquals(52, JavaLexer.LITERAL_CHAR, message);
+        assertEquals(53, JavaLexer.LITERAL_SHORT, message);
+        assertEquals(54, JavaLexer.LITERAL_INT, message);
+        assertEquals(55, JavaLexer.LITERAL_FLOAT, message);
+        assertEquals(56, JavaLexer.LITERAL_LONG, message);
+        assertEquals(57, JavaLexer.LITERAL_DOUBLE, message);
+        assertEquals(58, JavaLexer.IDENT, message);
+        assertEquals(59, JavaLexer.DOT, message);
+        assertEquals(60, JavaLexer.STAR, message);
+        assertEquals(61, JavaLexer.LITERAL_PRIVATE, message);
+        assertEquals(62, JavaLexer.LITERAL_PUBLIC, message);
+        assertEquals(63, JavaLexer.LITERAL_PROTECTED, message);
+        assertEquals(64, JavaLexer.LITERAL_STATIC, message);
+        assertEquals(65, JavaLexer.LITERAL_TRANSIENT, message);
+        assertEquals(66, JavaLexer.LITERAL_NATIVE, message);
+        assertEquals(67, JavaLexer.LITERAL_SYNCHRONIZED, message);
+        assertEquals(68, JavaLexer.LITERAL_VOLATILE, message);
+        assertEquals(69, JavaLexer.LITERAL_CLASS, message);
+        assertEquals(70, JavaLexer.LITERAL_EXTENDS, message);
+        assertEquals(71, JavaLexer.LITERAL_INTERFACE, message);
+        assertEquals(72, JavaLexer.LCURLY, message);
+        assertEquals(73, JavaLexer.RCURLY, message);
+        assertEquals(74, JavaLexer.COMMA, message);
+        assertEquals(75, JavaLexer.LITERAL_IMPLEMENTS, message);
+        assertEquals(76, JavaLexer.LPAREN, message);
+        assertEquals(77, JavaLexer.RPAREN, message);
+        assertEquals(78, JavaLexer.LITERAL_THIS, message);
+        assertEquals(79, JavaLexer.LITERAL_SUPER, message);
+        assertEquals(80, JavaLexer.ASSIGN, message);
+        assertEquals(81, JavaLexer.LITERAL_THROWS, message);
+        assertEquals(82, JavaLexer.COLON, message);
+        assertEquals(83, JavaLexer.LITERAL_IF, message);
+        assertEquals(84, JavaLexer.LITERAL_WHILE, message);
+        assertEquals(85, JavaLexer.LITERAL_DO, message);
+        assertEquals(86, JavaLexer.LITERAL_BREAK, message);
+        assertEquals(87, JavaLexer.LITERAL_CONTINUE, message);
+        assertEquals(88, JavaLexer.LITERAL_RETURN, message);
+        assertEquals(89, JavaLexer.LITERAL_SWITCH, message);
+        assertEquals(90, JavaLexer.LITERAL_THROW, message);
+        assertEquals(91, JavaLexer.LITERAL_FOR, message);
+        assertEquals(92, JavaLexer.LITERAL_ELSE, message);
+        assertEquals(93, JavaLexer.LITERAL_CASE, message);
+        assertEquals(94, JavaLexer.LITERAL_DEFAULT, message);
+        assertEquals(95, JavaLexer.LITERAL_TRY, message);
+        assertEquals(96, JavaLexer.LITERAL_CATCH, message);
+        assertEquals(97, JavaLexer.LITERAL_FINALLY, message);
+        assertEquals(98, JavaLexer.PLUS_ASSIGN, message);
+        assertEquals(99, JavaLexer.MINUS_ASSIGN, message);
+        assertEquals(100, JavaLexer.STAR_ASSIGN, message);
+        assertEquals(101, JavaLexer.DIV_ASSIGN, message);
+        assertEquals(102, JavaLexer.MOD_ASSIGN, message);
+        assertEquals(103, JavaLexer.SR_ASSIGN, message);
+        assertEquals(104, JavaLexer.BSR_ASSIGN, message);
+        assertEquals(105, JavaLexer.SL_ASSIGN, message);
+        assertEquals(106, JavaLexer.BAND_ASSIGN, message);
+        assertEquals(107, JavaLexer.BXOR_ASSIGN, message);
+        assertEquals(108, JavaLexer.BOR_ASSIGN, message);
+        assertEquals(109, JavaLexer.QUESTION, message);
+        assertEquals(110, JavaLexer.LOR, message);
+        assertEquals(111, JavaLexer.LAND, message);
+        assertEquals(112, JavaLexer.BOR, message);
+        assertEquals(113, JavaLexer.BXOR, message);
+        assertEquals(114, JavaLexer.BAND, message);
+        assertEquals(115, JavaLexer.NOT_EQUAL, message);
+        assertEquals(116, JavaLexer.EQUAL, message);
+        assertEquals(117, JavaLexer.LT, message);
+        assertEquals(118, JavaLexer.GT, message);
+        assertEquals(119, JavaLexer.LE, message);
+        assertEquals(120, JavaLexer.GE, message);
+        assertEquals(121, JavaLexer.LITERAL_INSTANCEOF, message);
+        assertEquals(122, JavaLexer.SL, message);
+        assertEquals(123, JavaLexer.SR, message);
+        assertEquals(124, JavaLexer.BSR, message);
+        assertEquals(125, JavaLexer.PLUS, message);
+        assertEquals(126, JavaLexer.MINUS, message);
+        assertEquals(127, JavaLexer.DIV, message);
+        assertEquals(128, JavaLexer.MOD, message);
+        assertEquals(129, JavaLexer.INC, message);
+        assertEquals(130, JavaLexer.DEC, message);
+        assertEquals(131, JavaLexer.BNOT, message);
+        assertEquals(132, JavaLexer.LNOT, message);
+        assertEquals(133, JavaLexer.LITERAL_TRUE, message);
+        assertEquals(134, JavaLexer.LITERAL_FALSE, message);
+        assertEquals(135, JavaLexer.LITERAL_NULL, message);
+        assertEquals(136, JavaLexer.LITERAL_NEW, message);
+        assertEquals(137, JavaLexer.NUM_INT, message);
+        assertEquals(138, JavaLexer.CHAR_LITERAL, message);
+        assertEquals(139, JavaLexer.STRING_LITERAL, message);
+        assertEquals(140, JavaLexer.NUM_FLOAT, message);
+        assertEquals(141, JavaLexer.NUM_LONG, message);
+        assertEquals(142, JavaLexer.NUM_DOUBLE, message);
+        assertEquals(143, JavaLexer.WS, message);
+        assertEquals(144, JavaLexer.SINGLE_LINE_COMMENT, message);
+        assertEquals(145, JavaLexer.BLOCK_COMMENT_BEGIN, message);
+        assertEquals(146, JavaLexer.ESC, message);
+        assertEquals(147, JavaLexer.HEX_DIGIT, message);
+        assertEquals(148, JavaLexer.VOCAB, message);
+        assertEquals(149, JavaLexer.EXPONENT, message);
+        assertEquals(150, JavaLexer.FLOAT_SUFFIX, message);
+        assertEquals(151, JavaLexer.ASSERT, message);
+        assertEquals(152, JavaLexer.STATIC_IMPORT, message);
+        assertEquals(153, JavaLexer.ENUM, message);
+        assertEquals(154, JavaLexer.ENUM_DEF, message);
+        assertEquals(155, JavaLexer.ENUM_CONSTANT_DEF, message);
+        assertEquals(156, JavaLexer.FOR_EACH_CLAUSE, message);
+        assertEquals(157, JavaLexer.ANNOTATION_DEF, message);
+        assertEquals(158, JavaLexer.ANNOTATIONS, message);
+        assertEquals(159, JavaLexer.ANNOTATION, message);
+        assertEquals(160, JavaLexer.ANNOTATION_MEMBER_VALUE_PAIR, message);
+        assertEquals(161, JavaLexer.ANNOTATION_FIELD_DEF, message);
+        assertEquals(162, JavaLexer.ANNOTATION_ARRAY_INIT, message);
+        assertEquals(163, JavaLexer.TYPE_ARGUMENTS, message);
+        assertEquals(164, JavaLexer.TYPE_ARGUMENT, message);
+        assertEquals(165, JavaLexer.TYPE_PARAMETERS, message);
+        assertEquals(166, JavaLexer.TYPE_PARAMETER, message);
+        assertEquals(167, JavaLexer.WILDCARD_TYPE, message);
+        assertEquals(168, JavaLexer.TYPE_UPPER_BOUNDS, message);
+        assertEquals(169, JavaLexer.TYPE_LOWER_BOUNDS, message);
+        assertEquals(170, JavaLexer.AT, message);
+        assertEquals(171, JavaLexer.ELLIPSIS, message);
+        assertEquals(172, JavaLexer.GENERIC_START, message);
+        assertEquals(173, JavaLexer.GENERIC_END, message);
+        assertEquals(174, JavaLexer.TYPE_EXTENSION_AND, message);
+        assertEquals(175, JavaLexer.DO_WHILE, message);
+        assertEquals(176, JavaLexer.RESOURCE_SPECIFICATION, message);
+        assertEquals(177, JavaLexer.RESOURCES, message);
+        assertEquals(178, JavaLexer.RESOURCE, message);
+        assertEquals(179, JavaLexer.DOUBLE_COLON, message);
+        assertEquals(180, JavaLexer.METHOD_REF, message);
+        assertEquals(181, JavaLexer.LAMBDA, message);
+        assertEquals(182, JavaLexer.BLOCK_COMMENT_END, message);
+        assertEquals(183, JavaLexer.COMMENT_CONTENT, message);
+        assertEquals(184, JavaLexer.SINGLE_LINE_COMMENT_CONTENT, message);
+        assertEquals(185, JavaLexer.BLOCK_COMMENT_CONTENT, message);
+        assertEquals(186, JavaLexer.STD_ESC, message);
+        assertEquals(187, JavaLexer.BINARY_DIGIT, message);
+        assertEquals(188, JavaLexer.ID_START, message);
+        assertEquals(189, JavaLexer.ID_PART, message);
+        assertEquals(190, JavaLexer.INT_LITERAL, message);
+        assertEquals(191, JavaLexer.LONG_LITERAL, message);
+        assertEquals(192, JavaLexer.FLOAT_LITERAL, message);
+        assertEquals(193, JavaLexer.DOUBLE_LITERAL, message);
+        assertEquals(194, JavaLexer.HEX_FLOAT_LITERAL, message);
+        assertEquals(195, JavaLexer.HEX_DOUBLE_LITERAL, message);
+        assertEquals(196, JavaLexer.SIGNED_INTEGER, message);
+        assertEquals(197, JavaLexer.BINARY_EXPONENT, message);
+        assertEquals(198, JavaLexer.PATTERN_VARIABLE_DEF, message);
+        assertEquals(199, JavaLexer.RECORD_DEF, message);
+        assertEquals(200, JavaLexer.LITERAL_RECORD, message);
+        assertEquals(201, JavaLexer.RECORD_COMPONENTS, message);
+        assertEquals(202, JavaLexer.RECORD_COMPONENT_DEF, message);
+        assertEquals(203, JavaLexer.COMPACT_CTOR_DEF, message);
+        assertEquals(204, JavaLexer.TEXT_BLOCK_LITERAL_BEGIN, message);
+        assertEquals(205, JavaLexer.TEXT_BLOCK_CONTENT, message);
+        assertEquals(206, JavaLexer.TEXT_BLOCK_LITERAL_END, message);
+        assertEquals(207, JavaLexer.LITERAL_YIELD, message);
+        assertEquals(208, JavaLexer.SWITCH_RULE, message);
+        assertEquals(209, JavaLexer.LITERAL_NON_SEALED, message);
+        assertEquals(210, JavaLexer.LITERAL_SEALED, message);
+        assertEquals(211, JavaLexer.LITERAL_PERMITS, message);
+        assertEquals(212, JavaLexer.PERMITS_CLAUSE, message);
 
         // Read JavaDoc before changing
-        assertEquals(212, GeneratedJavaTokenTypes.class.getDeclaredFields().length,
+        final int tokenCount = (int) Arrays.stream(JavaLexer.class.getDeclaredFields())
+                .filter(GeneratedJavaTokenTypesTest::isPublicStaticFinalInt)
+                .count();
+
+        assertEquals(224, tokenCount,
                 "all tokens must be added to list in"
                         + " 'GeneratedJavaTokenTypesTest' and verified"
                         + " that their old numbering didn't change");
     }
 
+    /**
+     * Checks that a given field is 'public static final int'.
+     *
+     * @param field field to verify type and visibility of
+     * @return true if field is declared as 'public static final int'
+     */
+    private static boolean isPublicStaticFinalInt(Field field) {
+        final Class<?> fieldType = field.getType();
+        final int mods = field.getModifiers();
+        return fieldType.equals(Integer.TYPE)
+                && Modifier.isPublic(mods)
+                && Modifier.isStatic(mods)
+                && Modifier.isFinal(mods);
+    }
 }
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/grammar/antlr4/Antlr4AstRegressionTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/grammar/antlr4/Antlr4AstRegressionTest.java
new file mode 100644
--- /dev/null
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/grammar/antlr4/Antlr4AstRegressionTest.java
@@ -0,0 +1,269 @@
+////////////////////////////////////////////////////////////////////////////////
+// checkstyle: Checks Java source code for adherence to a set of rules.
+// Copyright (C) 2001-2021 the original author or authors.
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+////////////////////////////////////////////////////////////////////////////////
+
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import org.junit.jupiter.api.Test;
+
+import com.puppycrawl.tools.checkstyle.AbstractTreeTestSupport;
+import com.puppycrawl.tools.checkstyle.JavaParser;
+
+public class Antlr4AstRegressionTest extends AbstractTreeTestSupport {
+
+    @Override
+    protected String getPackageLocation() {
+        return "com/puppycrawl/tools/checkstyle/grammar/antlr4";
+    }
+
+    @Test
+    public void testPackage() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionPackage.txt"),
+                getPath("InputAntlr4AstRegressionPackage.java"));
+    }
+
+    @Test
+    public void testSimple() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionSimple.txt"),
+                getPath("InputAntlr4AstRegressionSimple.java"));
+    }
+
+    @Test
+    public void testAnno() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionSimpleWithAnno.txt"),
+                getPath("InputAntlr4AstRegressionSimpleWithAnno.java"));
+    }
+
+    @Test
+    public void testImports() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionImports.txt"),
+                getPath("InputAntlr4AstRegressionImports.java"));
+    }
+
+    @Test
+    public void testConstructorCall() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionConstructorCall.txt"),
+                getPath("InputAntlr4AstRegressionConstructorCall.java"));
+    }
+
+    @Test
+    public void testMethodCall() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionMethodCall.txt"),
+                getPath("InputAntlr4AstRegressionMethodCall.java"));
+    }
+
+    @Test
+    public void testRegressionJavaClass1() throws Exception {
+        verifyAst(getPath("InputRegressionJavaClass1Ast.txt"),
+                getPath("InputRegressionJavaClass1.java"));
+    }
+
+    @Test
+    public void testRegressionAnnotationLocation() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionAnnotationLocation.txt"),
+                getPath("InputAntlr4AstRegressionAnnotationLocation.java"));
+    }
+
+    @Test
+    public void testRegressionKeywordsAndOperators() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionKeywordsAndOperators.txt"),
+                getPath("InputAntlr4AstRegressionKeywordsAndOperators.java"));
+    }
+
+    @Test
+    public void testRegressionDiamondOperators() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionKeywordsAndOperators.txt"),
+                getPath("InputAntlr4AstRegressionKeywordsAndOperators.java"));
+    }
+
+    @Test
+    public void testSingleLineBlocks() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionSingleLineBlocks.txt"),
+                getPath("InputAntlr4AstRegressionSingleLineBlocks.java"));
+    }
+
+    @Test
+    public void testExpressionList() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionExpressionList.txt"),
+                getPath("InputAntlr4AstRegressionExpressionList.java"));
+    }
+
+    @Test
+    public void testNewTypeTree() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionNewTypeTree.txt"),
+                getPath("InputAntlr4AstRegressionNewTypeTree.java"));
+    }
+
+    @Test
+    public void testFallThroughDefault() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionFallThroughDefault.txt"),
+                getPath("InputAntlr4AstRegressionFallThroughDefault.java"));
+    }
+
+    @Test
+    public void testPackageAnnotation() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionPackageAnnotation.txt"),
+                getPath("package-info.java"));
+    }
+
+    @Test
+    public void testAnnotationOnSameLine1() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionAnnotationOnSameLine.txt"),
+                getPath("InputAntlr4AstRegressionAnnotationOnSameLine.java"));
+    }
+
+    @Test
+    public void testAnnotationOnSameLine2() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionAnnotationOnSameLine2.txt"),
+                getPath("InputAntlr4AstRegressionAnnotationOnSameLine2.java"));
+    }
+
+    @Test
+    public void testSuppressWarnings() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionSuppressWarnings.txt"),
+                getPath("InputAntlr4AstRegressionSuppressWarnings.java"));
+    }
+
+    @Test
+    public void testBadOverride() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionBadOverride.txt"),
+                getPath("InputAntlr4AstRegressionBadOverride.java"));
+    }
+
+    @Test
+    public void testTrickySwitch() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionTrickySwitch.txt"),
+                getPath("InputAntlr4AstRegressionTrickySwitch.java"));
+    }
+
+    @Test
+    public void testExplicitInitialization() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionExplicitInitialization.txt"),
+                getPath("InputAntlr4AstRegressionExplicitInitialization.java"));
+    }
+
+    @Test
+    public void testTypeParams() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionTypeParams.txt"),
+                getPath("InputAntlr4AstRegressionTypeParams.java"));
+    }
+
+    @Test
+    public void testForLoops() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionForLoops.txt"),
+                getPath("InputAntlr4AstRegressionForLoops.java"));
+    }
+
+    @Test
+    public void testIllegalCatch() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionIllegalCatch.txt"),
+                getPath("InputAntlr4AstRegressionIllegalCatch.java"));
+    }
+
+    @Test
+    public void testNewLineAtEndOfFileCr() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionNewLineAtEndOfFileCr.txt"),
+                getPath("InputAntlr4AstRegressionNewLineAtEndOfFileCr.java"));
+    }
+
+    @Test
+    public void testWeirdCtor() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionWeirdCtor.txt"),
+                getPath("InputAntlr4AstRegressionWeirdCtor.java"));
+    }
+
+    @Test
+    public void testAnnotationOnQualifiedTypes() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionAnnotationOnQualifiedTypes.txt"),
+                getPath("InputAntlr4AstRegressionAnnotationOnQualifiedTypes.java"));
+    }
+
+    @Test
+    public void testAnnotationOnArrays() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionAnnotationOnArrays.txt"),
+                getPath("InputAntlr4AstRegressionAnnotationOnArrays.java"));
+    }
+
+    @Test
+    public void testMethodRefs() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionMethodRefs.txt"),
+                getPath("InputAntlr4AstRegressionMethodRefs.java"));
+    }
+
+    @Test
+    public void testEmbeddedBlockComments() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionEmbeddedBlockComments.txt"),
+                getPath("InputAntlr4AstRegressionEmbeddedBlockComments.java"));
+    }
+
+    @Test
+    public void testTrickySwitchWithComments() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionTrickySwitchWithComments.txt"),
+                getPath("InputAntlr4AstRegressionTrickySwitchWithComments.java"),
+                JavaParser.Options.WITH_COMMENTS);
+    }
+
+    @Test
+    public void testCassandraInputWithComments() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionCassandraInputWithComments.txt"),
+                getPath("InputAntlr4AstRegressionCassandraInputWithComments.java"),
+                JavaParser.Options.WITH_COMMENTS);
+    }
+
+    @Test
+    public void testCommentsOnAnnotationsAndEnums() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionCommentsOnAnnotationsAndEnums.txt"),
+                getPath("InputAntlr4AstRegressionCommentsOnAnnotationsAndEnums.java"),
+                JavaParser.Options.WITH_COMMENTS);
+    }
+
+    @Test
+    public void testUncommon() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionUncommon.txt"),
+                getNonCompilablePath("InputAntlr4AstRegressionUncommon.java"),
+                JavaParser.Options.WITH_COMMENTS);
+    }
+
+    @Test
+    public void testUncommon2() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionUncommon2.txt"),
+                getNonCompilablePath("InputAntlr4AstRegressionUncommon2.java"),
+                JavaParser.Options.WITH_COMMENTS);
+    }
+
+    @Test
+    public void testTrickyYield() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionTrickyYield.txt"),
+                getPath("InputAntlr4AstRegressionTrickyYield.java"),
+                JavaParser.Options.WITH_COMMENTS);
+    }
+
+    @Test
+    public void testUncommon3() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionUncommon3.txt"),
+                getNonCompilablePath("InputAntlr4AstRegressionUncommon3.java"),
+                JavaParser.Options.WITH_COMMENTS);
+    }
+
+    @Test
+    public void testUncommon4() throws Exception {
+        verifyAst(getPath("InputAntlr4AstRegressionUncommon4.txt"),
+                getPath("InputAntlr4AstRegressionUncommon4.java"),
+                JavaParser.Options.WITH_COMMENTS);
+    }
+}
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/gui/MainFrameModelTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/gui/MainFrameModelTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/gui/MainFrameModelTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/gui/MainFrameModelTest.java
@@ -154,7 +154,7 @@ public void testOpenFileNonCompilableFile() throws IOException {
         }
         catch (CheckstyleException ex) {
             final String expectedMsg = String.format(Locale.ROOT,
-                    "NoViableAltException occurred while parsing file %s.",
+                    "IllegalStateException occurred while parsing file %s.",
                     nonCompilableFile.getPath());
 
             assertEquals(expectedMsg, ex.getMessage(), "Invalid exception message");
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/utils/ScopeUtilTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/utils/ScopeUtilTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/utils/ScopeUtilTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/utils/ScopeUtilTest.java
@@ -26,7 +26,6 @@
 
 import org.junit.jupiter.api.Test;
 
-import antlr.collections.AST;
 import com.puppycrawl.tools.checkstyle.DetailAstImpl;
 import com.puppycrawl.tools.checkstyle.api.DetailAST;
 import com.puppycrawl.tools.checkstyle.api.Scope;
@@ -296,7 +295,7 @@ private static DetailAST getNodeWithParentScope(int literal, String scope,
         final DetailAstImpl ast = getNode(parentTokenType, TokenTypes.MODIFIERS, literal);
         ast.setText(scope);
         final DetailAstImpl ast2 = getNode(TokenTypes.OBJBLOCK);
-        ((AST) ast.getParent().getParent()).addChild(ast2);
+        ((DetailAstImpl) ast.getParent().getParent()).addChild(ast2);
         return ast;
     }
 
diff --git a/src/test/java/com/puppycrawl/tools/checkstyle/utils/TokenUtilTest.java b/src/test/java/com/puppycrawl/tools/checkstyle/utils/TokenUtilTest.java
--- a/src/test/java/com/puppycrawl/tools/checkstyle/utils/TokenUtilTest.java
+++ b/src/test/java/com/puppycrawl/tools/checkstyle/utils/TokenUtilTest.java
@@ -19,8 +19,8 @@
 
 package com.puppycrawl.tools.checkstyle.utils;
 
+import static com.google.common.truth.Truth.assertWithMessage;
 import static com.puppycrawl.tools.checkstyle.internal.utils.TestUtil.isUtilsClassHasPrivateConstructor;
-import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -89,18 +89,21 @@ public void testNameToValueMapFromPublicIntFields() {
     }
 
     @Test
-    public void testValueToNameArrayFromNameToValueMap() {
+    public void testInvertMap() {
         final Map<String, Integer> map = new TreeMap<>();
         map.put("ZERO", 0);
         map.put("ONE", 1);
         map.put("TWO", 2);
         map.put("NEGATIVE", -1);
 
-        final String[] actualArray =
-            TokenUtil.valueToNameArrayFromNameToValueMap(map);
-        final String[] expectedArray = {"ZERO", "ONE", "TWO"};
+        final Map<Integer, String> invertedMap = TokenUtil.invertMap(map);
 
-        assertArrayEquals(expectedArray, actualArray, "Unexpected value to name array");
+        assertWithMessage("Key set of 'map' and values of 'invertedMap' should be the same.")
+                .that(invertedMap.values())
+                .containsExactlyElementsIn(map.keySet());
+        assertWithMessage("Values of 'map' and key set of 'invertedMap' should be the same.")
+                .that(invertedMap.keySet())
+                .containsExactlyElementsIn(map.values());
     }
 
     @Test
@@ -217,7 +220,7 @@ public void testGetAllTokenIds() {
         final int sum = Arrays.stream(allTokenIds).sum();
 
         assertEquals(184, allTokenIds.length, "Invalid token length");
-        assertEquals(18737, sum, "invalid sum");
+        assertEquals(18735, sum, "invalid sum");
     }
 
     @Test
diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon.java b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon.java
@@ -0,0 +1,272 @@
+//non-compiled with javac: Compilable with Java16
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.function.IntFunction;
+
+import com.sun.tools.javac.Main;
+
+public class InputAntlr4AstRegressionUncommon
+        implements MyInterface {
+    int x[], y[], z[][];
+
+    public Double method1()[] {
+        return null;
+    }
+
+    protected <B, Z, A> OtherClass.Q<A,B,Z> m() {
+        return null;
+    }
+}
+
+interface MyInterface {
+    Double method1()[];
+}
+
+class OtherClass extends InputAntlr4AstRegressionUncommon {
+    OtherClass (int z){
+        super();
+    }
+    class Q<A, B, Z>{}
+
+    ;
+    public <Z, B, A> Q<A, Z, B> m() { return null;}
+
+    OtherClass (int z, String s){
+        new OtherClass(2);
+    }
+
+    class Inner {
+        Inner(int x) {}
+        Inner() {
+            this(2);
+            List<String> list = new List<>() {
+                @Override
+                public int size() {
+                    return 0;
+                }
+
+                @Override
+                public boolean isEmpty() {
+                    return false;
+                }
+
+                @Override
+                public boolean contains(Object o) {
+                    return false;
+                }
+
+                @Override
+                public Iterator<String> iterator() {
+                    return null;
+                }
+
+                @Override
+                public Object[] toArray() {
+                    return new Object[0];
+                }
+
+                @Override
+                public <T> T[] toArray(T[] a) {
+                    return null;
+                }
+
+                @Override
+                public boolean add(String s) {
+                    return false;
+                }
+
+                @Override
+                public boolean remove(Object o) {
+                    return false;
+                }
+
+                @Override
+                public boolean containsAll(Collection<?> c) {
+                    return false;
+                }
+
+                @Override
+                public boolean addAll(Collection<? extends String> c) {
+                    return false;
+                }
+
+                @Override
+                public boolean addAll(int index, Collection<? extends String> c) {
+                    return false;
+                }
+
+                @Override
+                public boolean removeAll(Collection<?> c) {
+                    return false;
+                }
+
+                @Override
+                public boolean retainAll(Collection<?> c) {
+                    return false;
+                }
+
+                @Override
+                public void clear() {
+
+                }
+
+                @Override
+                public String get(int index) {
+                    return null;
+                }
+
+                @Override
+                public String set(int index, String element) {
+                    return null;
+                }
+
+                @Override
+                public void add(int index, String element) {
+
+                }
+
+                @Override
+                public String remove(int index) {
+                    return null;
+                }
+
+                @Override
+                public int indexOf(Object o) {
+                    return 0;
+                }
+
+                @Override
+                public int lastIndexOf(Object o) {
+                    return 0;
+                }
+
+                @Override
+                public ListIterator<String> listIterator() {
+                    return null;
+                }
+
+                @Override
+                public ListIterator<String> listIterator(int index) {
+                    return null;
+                }
+
+                @Override
+                public List<String> subList(int fromIndex, int toIndex) {
+                    return null;
+                }
+            };
+        }
+    }
+
+    class OtherInner<E> {
+        OtherInner(int w){}
+        <T extends Serializable> OtherInner(T element) {
+
+        }
+        OtherInner() {
+            <E>this(2);
+        }
+    }
+
+    private void killAll() {
+          boolean oneAlive = false;
+              if (oneAlive) {
+                  Thread.yield();
+              }
+
+      }
+    class SuperClassA{
+        protected SuperClassA bs;
+        protected SuperClassA s;
+        Object s2;
+    }
+    class SuperClassA2{}
+
+
+    /*
+     * Note: inherited fields of a nested class shadow outer scope variables
+     *      Note: only if they are accessible!
+     */
+    public class FieldAccessSuper extends SuperClassA {
+        private SuperClassA s;
+
+        public void foo() {
+            // simple super field access
+            // Primary[Prefix[Name[s]]]
+            s = new SuperClassA();
+
+            // access inherited field through primary
+            // Primary[ Prefix[Primary[(this)]], Suffix[s], Suffix[s2] ]
+            (this).s.s2 = new SuperClassA2();
+
+            // access inherited field, second 's' has inherited field 's2'
+            // Primary[Prefix[Name[s.s.s2]]]
+            s.s.s2 = new SuperClassA2();
+
+            // field access through super
+            // Primary[Prefix["super"], Suffix["field"]]
+            super.s = new SuperClassA();
+
+            // fully qualified case
+            // Primary[Prefix[Name[net...FieldAccessSuper]], Suffix[this], Suffix[s]]
+            FieldAccessSuper.this.s
+                    = new SuperClassA();
+        }
+
+        public class Nested extends SuperClassA {
+            SuperClassA a;
+            class SubscriptionAdapter{}
+            final /* synthetic */ SubscriptionAdapter this$0 = null;
+            final /* synthetic */ Object val$argHolder = null;
+
+            public void foo() {
+                // access enclosing super field
+                // Primary[Prefix[Name[s]]]
+                s = new SuperClassA();
+
+                // access Nested inherited field
+                // Primary[Prefix[Name[bs]]]
+                bs = new SuperClassA();
+
+                // access super field with fully qualified stuff
+                // Primary[Prefix["FieldAccessSuper"], Suffix[Nested],
+                //                  Suffix["super"], Suffix["bs"]]
+                FieldAccessSuper.Nested.super.bs = new SuperClassA();
+
+                // refers to the enclosing class's immediate super class's field
+                // Primary[Prefix["FieldAccessSuper"], Suffix["super"], Suffix["s"]]
+                FieldAccessSuper.super.s = new SuperClassA();
+            }
+            Object x = Collections .<String, Integer>emptyMap();
+
+            Nested() {
+                super();
+            }
+
+            int bar() {
+                return super.hashCode();
+            }
+
+            boolean method() {
+                return super.equals(new Object());
+            }
+        }
+    }
+
+
+}
+
+record TestRecord(int[] x, int[]... y) {
+    void foo() {
+        Runnable r11 = Main::<String>new;
+        IntFunction<int[]> r13 = int[]::<String>new; // produces the same results
+    }
+}
+
+;;;
diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon2.java b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon2.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon2.java
@@ -0,0 +1,52 @@
+package
+         com                .puppycrawl.
+                tools.
+                checkstyle
+                .grammar.
+                antlr4
+        ;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class InputAntlr4AstRegressionUncommon2 {
+    public @interface PackgeAnno {
+    }
+    @Nullable List<Integer> x = new ArrayList<Integer>();
+    enum
+    FPMethodArgs
+    {
+
+        IGNN,
+        IIGNN,
+        GNNII,
+        GNNC;;;;;
+    }
+    public
+    interface
+    IntEnum
+    {
+    }
+
+    private
+    @interface
+    MyOtherAnno
+    {
+        public class
+        Test {}
+        enum
+        TestEnum{}
+        public @interface
+        InnerAnnoDeclaration{}
+        int x = 0;
+        int method();
+        ;;;;;
+    }
+    private String str = ""
+          +""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+""+"";
+    int z = 42 + 42;
+    @ interface Foo {
+        String v1()[];
+    }
+    @interface Nullable{}
+}
diff --git a/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon3.java b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon3.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources-noncompilable/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon3.java
@@ -0,0 +1,70 @@
+//non-compiled with javac: Compilable with Java16
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+public class InputAntlr4AstRegressionUncommon3 implements AutoCloseable {
+    @Override
+    public void close() throws Exception {
+
+    }
+
+    interface SAM {
+        int m();
+    }
+
+    interface SuperI {
+        public default int foo() { return 1234; }
+    }
+
+    interface I extends SuperI {
+    }
+
+    interface T extends I {
+        public default SAM boo() { return I.super::foo; }
+    }
+
+    interface DSPRI { String m(String a); }
+
+    interface DSPRA {
+        default String xsA__(String s) {
+            return "A__xsA:" + s;
+        }
+
+        default String xsAB_(String s) {
+            return "AB_xsA:" + s;
+        }
+
+    }
+
+    interface DSPRB extends DSPRA {
+
+        default String xsAB_(String s) {
+            return "AB_xsB:" + s;
+        }
+
+        default String xs_B_(String s) {
+            return "_B_xsB:" + s;
+        }
+
+    }
+
+    public class MethodReferenceTestSuperDefault implements DSPRB {
+
+        public void testMethodReferenceSuper() {
+            DSPRI q;
+
+            q = DSPRB.super::xsA__;
+
+            q = DSPRB.super::xsAB_;
+
+            q = DSPRB.super::xs_B_;
+        }
+
+    }
+
+    void test() throws Exception {
+        try (InputAntlr4AstRegressionUncommon3.this) {
+            System.out.println("Unable to process");
+        }
+    }
+
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/checks/whitespace/whitespaceafter/InputWhitespaceAfterCountUnicodeCorrectly.java b/src/test/resources/com/puppycrawl/tools/checkstyle/checks/whitespace/whitespaceafter/InputWhitespaceAfterCountUnicodeCorrectly.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/checks/whitespace/whitespaceafter/InputWhitespaceAfterCountUnicodeCorrectly.java
@@ -0,0 +1,11 @@
+package com.puppycrawl.tools.checkstyle.checks.whitespace.whitespaceafter;
+
+/* Config:
+ * default
+ */
+public class InputWhitespaceAfterCountUnicodeCorrectly {
+    String a = "  ";
+    String b = "💩💩";
+    String c = "💩💩";// violation
+    String d = "💩💩"; // ok
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationLocation.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationLocation.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationLocation.java
@@ -0,0 +1,31 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.Target;
+
+
+@AnnotationAnnotation(value = "foo")
+  @AnnotationAnnotation // violation
+@AnnotationAnnotation("bar") @interface InputAntlr4AstRegressionAnnotationLocation { // violation
+
+    @AnnotationAnnotation(value = "foo")
+      @AnnotationAnnotation // violation
+    @AnnotationAnnotation("bar") String value(); // violation
+
+}
+
+@Repeatable(AnnotationAnnotations.class)
+@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD})
+@interface AnnotationAnnotation  {
+
+    String value() default "";
+
+}
+
+@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD})
+@interface AnnotationAnnotations {
+
+    AnnotationAnnotation[] value();
+
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationLocation.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationLocation.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationLocation.txt
@@ -0,0 +1,175 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+IMPORT -> import [3:0]
+|--DOT -> . [3:27]
+|   |--DOT -> . [3:16]
+|   |   |--DOT -> . [3:11]
+|   |   |   |--IDENT -> java [3:7]
+|   |   |   `--IDENT -> lang [3:12]
+|   |   `--IDENT -> annotation [3:17]
+|   `--IDENT -> ElementType [3:28]
+`--SEMI -> ; [3:39]
+IMPORT -> import [4:0]
+|--DOT -> . [4:27]
+|   |--DOT -> . [4:16]
+|   |   |--DOT -> . [4:11]
+|   |   |   |--IDENT -> java [4:7]
+|   |   |   `--IDENT -> lang [4:12]
+|   |   `--IDENT -> annotation [4:17]
+|   `--IDENT -> Repeatable [4:28]
+`--SEMI -> ; [4:38]
+IMPORT -> import [5:0]
+|--DOT -> . [5:27]
+|   |--DOT -> . [5:16]
+|   |   |--DOT -> . [5:11]
+|   |   |   |--IDENT -> java [5:7]
+|   |   |   `--IDENT -> lang [5:12]
+|   |   `--IDENT -> annotation [5:17]
+|   `--IDENT -> Target [5:28]
+`--SEMI -> ; [5:34]
+ANNOTATION_DEF -> ANNOTATION_DEF [8:0]
+|--MODIFIERS -> MODIFIERS [8:0]
+|   |--ANNOTATION -> ANNOTATION [8:0]
+|   |   |--AT -> @ [8:0]
+|   |   |--IDENT -> AnnotationAnnotation [8:1]
+|   |   |--LPAREN -> ( [8:21]
+|   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [8:22]
+|   |   |   |--IDENT -> value [8:22]
+|   |   |   |--ASSIGN -> = [8:28]
+|   |   |   `--EXPR -> EXPR [8:30]
+|   |   |       `--STRING_LITERAL -> "foo" [8:30]
+|   |   `--RPAREN -> ) [8:35]
+|   |--ANNOTATION -> ANNOTATION [9:2]
+|   |   |--AT -> @ [9:2]
+|   |   `--IDENT -> AnnotationAnnotation [9:3]
+|   `--ANNOTATION -> ANNOTATION [10:0]
+|       |--AT -> @ [10:0]
+|       |--IDENT -> AnnotationAnnotation [10:1]
+|       |--LPAREN -> ( [10:21]
+|       |--EXPR -> EXPR [10:22]
+|       |   `--STRING_LITERAL -> "bar" [10:22]
+|       `--RPAREN -> ) [10:27]
+|--AT -> @ [10:29]
+|--LITERAL_INTERFACE -> interface [10:30]
+|--IDENT -> InputAntlr4AstRegressionAnnotationLocation [10:40]
+`--OBJBLOCK -> OBJBLOCK [10:83]
+    |--LCURLY -> { [10:83]
+    |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [12:4]
+    |   |--MODIFIERS -> MODIFIERS [12:4]
+    |   |   |--ANNOTATION -> ANNOTATION [12:4]
+    |   |   |   |--AT -> @ [12:4]
+    |   |   |   |--IDENT -> AnnotationAnnotation [12:5]
+    |   |   |   |--LPAREN -> ( [12:25]
+    |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [12:26]
+    |   |   |   |   |--IDENT -> value [12:26]
+    |   |   |   |   |--ASSIGN -> = [12:32]
+    |   |   |   |   `--EXPR -> EXPR [12:34]
+    |   |   |   |       `--STRING_LITERAL -> "foo" [12:34]
+    |   |   |   `--RPAREN -> ) [12:39]
+    |   |   |--ANNOTATION -> ANNOTATION [13:6]
+    |   |   |   |--AT -> @ [13:6]
+    |   |   |   `--IDENT -> AnnotationAnnotation [13:7]
+    |   |   `--ANNOTATION -> ANNOTATION [14:4]
+    |   |       |--AT -> @ [14:4]
+    |   |       |--IDENT -> AnnotationAnnotation [14:5]
+    |   |       |--LPAREN -> ( [14:25]
+    |   |       |--EXPR -> EXPR [14:26]
+    |   |       |   `--STRING_LITERAL -> "bar" [14:26]
+    |   |       `--RPAREN -> ) [14:31]
+    |   |--TYPE -> TYPE [14:33]
+    |   |   `--IDENT -> String [14:33]
+    |   |--IDENT -> value [14:40]
+    |   |--LPAREN -> ( [14:45]
+    |   |--RPAREN -> ) [14:46]
+    |   `--SEMI -> ; [14:47]
+    `--RCURLY -> } [16:0]
+ANNOTATION_DEF -> ANNOTATION_DEF [18:0]
+|--MODIFIERS -> MODIFIERS [18:0]
+|   |--ANNOTATION -> ANNOTATION [18:0]
+|   |   |--AT -> @ [18:0]
+|   |   |--IDENT -> Repeatable [18:1]
+|   |   |--LPAREN -> ( [18:11]
+|   |   |--EXPR -> EXPR [18:33]
+|   |   |   `--DOT -> . [18:33]
+|   |   |       |--IDENT -> AnnotationAnnotations [18:12]
+|   |   |       `--LITERAL_CLASS -> class [18:34]
+|   |   `--RPAREN -> ) [18:39]
+|   `--ANNOTATION -> ANNOTATION [19:0]
+|       |--AT -> @ [19:0]
+|       |--IDENT -> Target [19:1]
+|       |--LPAREN -> ( [19:7]
+|       |--ANNOTATION_ARRAY_INIT -> { [19:8]
+|       |   |--EXPR -> EXPR [19:20]
+|       |   |   `--DOT -> . [19:20]
+|       |   |       |--IDENT -> ElementType [19:9]
+|       |   |       `--IDENT -> ANNOTATION_TYPE [19:21]
+|       |   |--COMMA -> , [19:36]
+|       |   |--EXPR -> EXPR [19:49]
+|       |   |   `--DOT -> . [19:49]
+|       |   |       |--IDENT -> ElementType [19:38]
+|       |   |       `--IDENT -> METHOD [19:50]
+|       |   `--RCURLY -> } [19:56]
+|       `--RPAREN -> ) [19:57]
+|--AT -> @ [20:0]
+|--LITERAL_INTERFACE -> interface [20:1]
+|--IDENT -> AnnotationAnnotation [20:11]
+`--OBJBLOCK -> OBJBLOCK [20:33]
+    |--LCURLY -> { [20:33]
+    |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [22:4]
+    |   |--MODIFIERS -> MODIFIERS [22:4]
+    |   |--TYPE -> TYPE [22:4]
+    |   |   `--IDENT -> String [22:4]
+    |   |--IDENT -> value [22:11]
+    |   |--LPAREN -> ( [22:16]
+    |   |--RPAREN -> ) [22:17]
+    |   |--LITERAL_DEFAULT -> default [22:19]
+    |   |   `--EXPR -> EXPR [22:27]
+    |   |       `--STRING_LITERAL -> "" [22:27]
+    |   `--SEMI -> ; [22:29]
+    `--RCURLY -> } [24:0]
+ANNOTATION_DEF -> ANNOTATION_DEF [26:0]
+|--MODIFIERS -> MODIFIERS [26:0]
+|   `--ANNOTATION -> ANNOTATION [26:0]
+|       |--AT -> @ [26:0]
+|       |--IDENT -> Target [26:1]
+|       |--LPAREN -> ( [26:7]
+|       |--ANNOTATION_ARRAY_INIT -> { [26:8]
+|       |   |--EXPR -> EXPR [26:20]
+|       |   |   `--DOT -> . [26:20]
+|       |   |       |--IDENT -> ElementType [26:9]
+|       |   |       `--IDENT -> ANNOTATION_TYPE [26:21]
+|       |   |--COMMA -> , [26:36]
+|       |   |--EXPR -> EXPR [26:49]
+|       |   |   `--DOT -> . [26:49]
+|       |   |       |--IDENT -> ElementType [26:38]
+|       |   |       `--IDENT -> METHOD [26:50]
+|       |   `--RCURLY -> } [26:56]
+|       `--RPAREN -> ) [26:57]
+|--AT -> @ [27:0]
+|--LITERAL_INTERFACE -> interface [27:1]
+|--IDENT -> AnnotationAnnotations [27:11]
+`--OBJBLOCK -> OBJBLOCK [27:33]
+    |--LCURLY -> { [27:33]
+    |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [29:4]
+    |   |--MODIFIERS -> MODIFIERS [29:4]
+    |   |--TYPE -> TYPE [29:4]
+    |   |   |--IDENT -> AnnotationAnnotation [29:4]
+    |   |   `--ARRAY_DECLARATOR -> [ [29:24]
+    |   |       `--RBRACK -> ] [29:25]
+    |   |--IDENT -> value [29:27]
+    |   |--LPAREN -> ( [29:32]
+    |   |--RPAREN -> ) [29:33]
+    |   `--SEMI -> ; [29:34]
+    `--RCURLY -> } [31:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnArrays.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnArrays.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnArrays.java
@@ -0,0 +1,53 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import static java.lang.annotation.ElementType.TYPE_USE;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+public class InputAntlr4AstRegressionAnnotationOnArrays {
+
+    private String array1 @Nullable [];
+    private @Nullable int array2 @Nullable [] @Nullable [];
+
+    private InputAntlr4AstRegressionAnnotationOnArrays() {
+    }
+
+    public static <T> T[] checkNotNullContents(T @Nullable [] array) {
+        if (array == null) {
+            throw new NullPointerException();
+        }
+
+        return array;
+    }
+
+    public static <T> T[][] checkNotNullContents2(T @Nullable [] @Nullable [] array) {
+        if (array == null) {
+            throw new NullPointerException();
+        }
+
+        return array;
+    }
+
+    public static <T> T @Nullable [] checkNotNullContents3(T array @Nullable []) {
+        if (array == null) {
+            throw new NullPointerException();
+        }
+
+        return array;
+    }
+
+    public <T> T checkNotNullContents4(T @Nullable [] array) @Nullable [] {
+        if (array == null) {
+            throw new NullPointerException();
+        }
+        String tmp1 @Nullable [];
+        @Nullable Object[] tmp2 = new @Nullable Integer[3];
+        @Nullable int[] tmp3 = new @Nullable int[3];
+        @Nullable Object tmp4 = new @Nullable String @Nullable [3] @Nullable [2];
+        @Nullable Object tmp5 = new @Nullable int @Nullable [3] @Nullable [2];
+
+        return array;
+    }
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnArrays.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnArrays.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnArrays.txt
@@ -0,0 +1,448 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+STATIC_IMPORT -> import [3:0]
+|--LITERAL_STATIC -> static [3:7]
+|--DOT -> . [3:46]
+|   |--DOT -> . [3:34]
+|   |   |--DOT -> . [3:23]
+|   |   |   |--DOT -> . [3:18]
+|   |   |   |   |--IDENT -> java [3:14]
+|   |   |   |   `--IDENT -> lang [3:19]
+|   |   |   `--IDENT -> annotation [3:24]
+|   |   `--IDENT -> ElementType [3:35]
+|   `--IDENT -> TYPE_USE [3:47]
+`--SEMI -> ; [3:55]
+IMPORT -> import [5:0]
+|--DOT -> . [5:27]
+|   |--DOT -> . [5:16]
+|   |   |--DOT -> . [5:11]
+|   |   |   |--IDENT -> java [5:7]
+|   |   |   `--IDENT -> lang [5:12]
+|   |   `--IDENT -> annotation [5:17]
+|   `--IDENT -> Retention [5:28]
+`--SEMI -> ; [5:37]
+IMPORT -> import [6:0]
+|--DOT -> . [6:27]
+|   |--DOT -> . [6:16]
+|   |   |--DOT -> . [6:11]
+|   |   |   |--IDENT -> java [6:7]
+|   |   |   `--IDENT -> lang [6:12]
+|   |   `--IDENT -> annotation [6:17]
+|   `--IDENT -> RetentionPolicy [6:28]
+`--SEMI -> ; [6:43]
+IMPORT -> import [7:0]
+|--DOT -> . [7:27]
+|   |--DOT -> . [7:16]
+|   |   |--DOT -> . [7:11]
+|   |   |   |--IDENT -> java [7:7]
+|   |   |   `--IDENT -> lang [7:12]
+|   |   `--IDENT -> annotation [7:17]
+|   `--IDENT -> Target [7:28]
+`--SEMI -> ; [7:34]
+CLASS_DEF -> CLASS_DEF [9:0]
+|--MODIFIERS -> MODIFIERS [9:0]
+|   `--LITERAL_PUBLIC -> public [9:0]
+|--LITERAL_CLASS -> class [9:7]
+|--IDENT -> InputAntlr4AstRegressionAnnotationOnArrays [9:13]
+`--OBJBLOCK -> OBJBLOCK [9:56]
+    |--LCURLY -> { [9:56]
+    |--VARIABLE_DEF -> VARIABLE_DEF [11:4]
+    |   |--MODIFIERS -> MODIFIERS [11:4]
+    |   |   `--LITERAL_PRIVATE -> private [11:4]
+    |   |--TYPE -> TYPE [11:12]
+    |   |   |--IDENT -> String [11:12]
+    |   |   |--ANNOTATIONS -> ANNOTATIONS [11:26]
+    |   |   |   `--ANNOTATION -> ANNOTATION [11:26]
+    |   |   |       |--AT -> @ [11:26]
+    |   |   |       `--IDENT -> Nullable [11:27]
+    |   |   `--ARRAY_DECLARATOR -> [ [11:36]
+    |   |       `--RBRACK -> ] [11:37]
+    |   |--IDENT -> array1 [11:19]
+    |   `--SEMI -> ; [11:38]
+    |--VARIABLE_DEF -> VARIABLE_DEF [12:4]
+    |   |--MODIFIERS -> MODIFIERS [12:4]
+    |   |   |--LITERAL_PRIVATE -> private [12:4]
+    |   |   `--ANNOTATION -> ANNOTATION [12:12]
+    |   |       |--AT -> @ [12:12]
+    |   |       `--IDENT -> Nullable [12:13]
+    |   |--TYPE -> TYPE [12:22]
+    |   |   |--LITERAL_INT -> int [12:22]
+    |   |   |--ANNOTATIONS -> ANNOTATIONS [12:33]
+    |   |   |   `--ANNOTATION -> ANNOTATION [12:33]
+    |   |   |       |--AT -> @ [12:33]
+    |   |   |       `--IDENT -> Nullable [12:34]
+    |   |   |--ARRAY_DECLARATOR -> [ [12:43]
+    |   |   |   `--RBRACK -> ] [12:44]
+    |   |   |--ANNOTATIONS -> ANNOTATIONS [12:46]
+    |   |   |   `--ANNOTATION -> ANNOTATION [12:46]
+    |   |   |       |--AT -> @ [12:46]
+    |   |   |       `--IDENT -> Nullable [12:47]
+    |   |   `--ARRAY_DECLARATOR -> [ [12:56]
+    |   |       `--RBRACK -> ] [12:57]
+    |   |--IDENT -> array2 [12:26]
+    |   `--SEMI -> ; [12:58]
+    |--CTOR_DEF -> CTOR_DEF [14:4]
+    |   |--MODIFIERS -> MODIFIERS [14:4]
+    |   |   `--LITERAL_PRIVATE -> private [14:4]
+    |   |--IDENT -> InputAntlr4AstRegressionAnnotationOnArrays [14:12]
+    |   |--LPAREN -> ( [14:54]
+    |   |--PARAMETERS -> PARAMETERS [14:55]
+    |   |--RPAREN -> ) [14:55]
+    |   `--SLIST -> { [14:57]
+    |       `--RCURLY -> } [15:4]
+    |--METHOD_DEF -> METHOD_DEF [17:4]
+    |   |--MODIFIERS -> MODIFIERS [17:4]
+    |   |   |--LITERAL_PUBLIC -> public [17:4]
+    |   |   `--LITERAL_STATIC -> static [17:11]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [17:18]
+    |   |   |--GENERIC_START -> < [17:18]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [17:19]
+    |   |   |   `--IDENT -> T [17:19]
+    |   |   `--GENERIC_END -> > [17:20]
+    |   |--TYPE -> TYPE [17:22]
+    |   |   |--IDENT -> T [17:22]
+    |   |   `--ARRAY_DECLARATOR -> [ [17:23]
+    |   |       `--RBRACK -> ] [17:24]
+    |   |--IDENT -> checkNotNullContents [17:26]
+    |   |--LPAREN -> ( [17:46]
+    |   |--PARAMETERS -> PARAMETERS [17:47]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [17:47]
+    |   |       |--MODIFIERS -> MODIFIERS [17:47]
+    |   |       |--TYPE -> TYPE [17:47]
+    |   |       |   |--IDENT -> T [17:47]
+    |   |       |   |--ANNOTATIONS -> ANNOTATIONS [17:49]
+    |   |       |   |   `--ANNOTATION -> ANNOTATION [17:49]
+    |   |       |   |       |--AT -> @ [17:49]
+    |   |       |   |       `--IDENT -> Nullable [17:50]
+    |   |       |   `--ARRAY_DECLARATOR -> [ [17:59]
+    |   |       |       `--RBRACK -> ] [17:60]
+    |   |       `--IDENT -> array [17:62]
+    |   |--RPAREN -> ) [17:67]
+    |   `--SLIST -> { [17:69]
+    |       |--LITERAL_IF -> if [18:8]
+    |       |   |--LPAREN -> ( [18:11]
+    |       |   |--EXPR -> EXPR [18:18]
+    |       |   |   `--EQUAL -> == [18:18]
+    |       |   |       |--IDENT -> array [18:12]
+    |       |   |       `--LITERAL_NULL -> null [18:21]
+    |       |   |--RPAREN -> ) [18:25]
+    |       |   `--SLIST -> { [18:27]
+    |       |       |--LITERAL_THROW -> throw [19:12]
+    |       |       |   |--EXPR -> EXPR [19:18]
+    |       |       |   |   `--LITERAL_NEW -> new [19:18]
+    |       |       |   |       |--IDENT -> NullPointerException [19:22]
+    |       |       |   |       |--LPAREN -> ( [19:42]
+    |       |       |   |       |--ELIST -> ELIST [19:43]
+    |       |       |   |       `--RPAREN -> ) [19:43]
+    |       |       |   `--SEMI -> ; [19:44]
+    |       |       `--RCURLY -> } [20:8]
+    |       |--LITERAL_RETURN -> return [22:8]
+    |       |   |--EXPR -> EXPR [22:15]
+    |       |   |   `--IDENT -> array [22:15]
+    |       |   `--SEMI -> ; [22:20]
+    |       `--RCURLY -> } [23:4]
+    |--METHOD_DEF -> METHOD_DEF [25:4]
+    |   |--MODIFIERS -> MODIFIERS [25:4]
+    |   |   |--LITERAL_PUBLIC -> public [25:4]
+    |   |   `--LITERAL_STATIC -> static [25:11]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [25:18]
+    |   |   |--GENERIC_START -> < [25:18]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [25:19]
+    |   |   |   `--IDENT -> T [25:19]
+    |   |   `--GENERIC_END -> > [25:20]
+    |   |--TYPE -> TYPE [25:22]
+    |   |   |--IDENT -> T [25:22]
+    |   |   |--ARRAY_DECLARATOR -> [ [25:23]
+    |   |   |   `--RBRACK -> ] [25:24]
+    |   |   `--ARRAY_DECLARATOR -> [ [25:25]
+    |   |       `--RBRACK -> ] [25:26]
+    |   |--IDENT -> checkNotNullContents2 [25:28]
+    |   |--LPAREN -> ( [25:49]
+    |   |--PARAMETERS -> PARAMETERS [25:50]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [25:50]
+    |   |       |--MODIFIERS -> MODIFIERS [25:50]
+    |   |       |--TYPE -> TYPE [25:50]
+    |   |       |   |--IDENT -> T [25:50]
+    |   |       |   |--ANNOTATIONS -> ANNOTATIONS [25:52]
+    |   |       |   |   `--ANNOTATION -> ANNOTATION [25:52]
+    |   |       |   |       |--AT -> @ [25:52]
+    |   |       |   |       `--IDENT -> Nullable [25:53]
+    |   |       |   |--ARRAY_DECLARATOR -> [ [25:62]
+    |   |       |   |   `--RBRACK -> ] [25:63]
+    |   |       |   |--ANNOTATIONS -> ANNOTATIONS [25:65]
+    |   |       |   |   `--ANNOTATION -> ANNOTATION [25:65]
+    |   |       |   |       |--AT -> @ [25:65]
+    |   |       |   |       `--IDENT -> Nullable [25:66]
+    |   |       |   `--ARRAY_DECLARATOR -> [ [25:75]
+    |   |       |       `--RBRACK -> ] [25:76]
+    |   |       `--IDENT -> array [25:78]
+    |   |--RPAREN -> ) [25:83]
+    |   `--SLIST -> { [25:85]
+    |       |--LITERAL_IF -> if [26:8]
+    |       |   |--LPAREN -> ( [26:11]
+    |       |   |--EXPR -> EXPR [26:18]
+    |       |   |   `--EQUAL -> == [26:18]
+    |       |   |       |--IDENT -> array [26:12]
+    |       |   |       `--LITERAL_NULL -> null [26:21]
+    |       |   |--RPAREN -> ) [26:25]
+    |       |   `--SLIST -> { [26:27]
+    |       |       |--LITERAL_THROW -> throw [27:12]
+    |       |       |   |--EXPR -> EXPR [27:18]
+    |       |       |   |   `--LITERAL_NEW -> new [27:18]
+    |       |       |   |       |--IDENT -> NullPointerException [27:22]
+    |       |       |   |       |--LPAREN -> ( [27:42]
+    |       |       |   |       |--ELIST -> ELIST [27:43]
+    |       |       |   |       `--RPAREN -> ) [27:43]
+    |       |       |   `--SEMI -> ; [27:44]
+    |       |       `--RCURLY -> } [28:8]
+    |       |--LITERAL_RETURN -> return [30:8]
+    |       |   |--EXPR -> EXPR [30:15]
+    |       |   |   `--IDENT -> array [30:15]
+    |       |   `--SEMI -> ; [30:20]
+    |       `--RCURLY -> } [31:4]
+    |--METHOD_DEF -> METHOD_DEF [33:4]
+    |   |--MODIFIERS -> MODIFIERS [33:4]
+    |   |   |--LITERAL_PUBLIC -> public [33:4]
+    |   |   `--LITERAL_STATIC -> static [33:11]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [33:18]
+    |   |   |--GENERIC_START -> < [33:18]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [33:19]
+    |   |   |   `--IDENT -> T [33:19]
+    |   |   `--GENERIC_END -> > [33:20]
+    |   |--TYPE -> TYPE [33:22]
+    |   |   |--IDENT -> T [33:22]
+    |   |   |--ANNOTATIONS -> ANNOTATIONS [33:24]
+    |   |   |   `--ANNOTATION -> ANNOTATION [33:24]
+    |   |   |       |--AT -> @ [33:24]
+    |   |   |       `--IDENT -> Nullable [33:25]
+    |   |   `--ARRAY_DECLARATOR -> [ [33:34]
+    |   |       `--RBRACK -> ] [33:35]
+    |   |--IDENT -> checkNotNullContents3 [33:37]
+    |   |--LPAREN -> ( [33:58]
+    |   |--PARAMETERS -> PARAMETERS [33:59]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [33:59]
+    |   |       |--MODIFIERS -> MODIFIERS [33:59]
+    |   |       |--TYPE -> TYPE [33:59]
+    |   |       |   |--IDENT -> T [33:59]
+    |   |       |   |--ANNOTATIONS -> ANNOTATIONS [33:67]
+    |   |       |   |   `--ANNOTATION -> ANNOTATION [33:67]
+    |   |       |   |       |--AT -> @ [33:67]
+    |   |       |   |       `--IDENT -> Nullable [33:68]
+    |   |       |   `--ARRAY_DECLARATOR -> [ [33:77]
+    |   |       |       `--RBRACK -> ] [33:78]
+    |   |       `--IDENT -> array [33:61]
+    |   |--RPAREN -> ) [33:79]
+    |   `--SLIST -> { [33:81]
+    |       |--LITERAL_IF -> if [34:8]
+    |       |   |--LPAREN -> ( [34:11]
+    |       |   |--EXPR -> EXPR [34:18]
+    |       |   |   `--EQUAL -> == [34:18]
+    |       |   |       |--IDENT -> array [34:12]
+    |       |   |       `--LITERAL_NULL -> null [34:21]
+    |       |   |--RPAREN -> ) [34:25]
+    |       |   `--SLIST -> { [34:27]
+    |       |       |--LITERAL_THROW -> throw [35:12]
+    |       |       |   |--EXPR -> EXPR [35:18]
+    |       |       |   |   `--LITERAL_NEW -> new [35:18]
+    |       |       |   |       |--IDENT -> NullPointerException [35:22]
+    |       |       |   |       |--LPAREN -> ( [35:42]
+    |       |       |   |       |--ELIST -> ELIST [35:43]
+    |       |       |   |       `--RPAREN -> ) [35:43]
+    |       |       |   `--SEMI -> ; [35:44]
+    |       |       `--RCURLY -> } [36:8]
+    |       |--LITERAL_RETURN -> return [38:8]
+    |       |   |--EXPR -> EXPR [38:15]
+    |       |   |   `--IDENT -> array [38:15]
+    |       |   `--SEMI -> ; [38:20]
+    |       `--RCURLY -> } [39:4]
+    |--METHOD_DEF -> METHOD_DEF [41:4]
+    |   |--MODIFIERS -> MODIFIERS [41:4]
+    |   |   `--LITERAL_PUBLIC -> public [41:4]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [41:11]
+    |   |   |--GENERIC_START -> < [41:11]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [41:12]
+    |   |   |   `--IDENT -> T [41:12]
+    |   |   `--GENERIC_END -> > [41:13]
+    |   |--TYPE -> TYPE [41:15]
+    |   |   |--IDENT -> T [41:15]
+    |   |   |--ANNOTATIONS -> ANNOTATIONS [41:61]
+    |   |   |   `--ANNOTATION -> ANNOTATION [41:61]
+    |   |   |       |--AT -> @ [41:61]
+    |   |   |       `--IDENT -> Nullable [41:62]
+    |   |   `--ARRAY_DECLARATOR -> [ [41:71]
+    |   |       `--RBRACK -> ] [41:72]
+    |   |--IDENT -> checkNotNullContents4 [41:17]
+    |   |--LPAREN -> ( [41:38]
+    |   |--PARAMETERS -> PARAMETERS [41:39]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [41:39]
+    |   |       |--MODIFIERS -> MODIFIERS [41:39]
+    |   |       |--TYPE -> TYPE [41:39]
+    |   |       |   |--IDENT -> T [41:39]
+    |   |       |   |--ANNOTATIONS -> ANNOTATIONS [41:41]
+    |   |       |   |   `--ANNOTATION -> ANNOTATION [41:41]
+    |   |       |   |       |--AT -> @ [41:41]
+    |   |       |   |       `--IDENT -> Nullable [41:42]
+    |   |       |   `--ARRAY_DECLARATOR -> [ [41:51]
+    |   |       |       `--RBRACK -> ] [41:52]
+    |   |       `--IDENT -> array [41:54]
+    |   |--RPAREN -> ) [41:59]
+    |   `--SLIST -> { [41:74]
+    |       |--LITERAL_IF -> if [42:8]
+    |       |   |--LPAREN -> ( [42:11]
+    |       |   |--EXPR -> EXPR [42:18]
+    |       |   |   `--EQUAL -> == [42:18]
+    |       |   |       |--IDENT -> array [42:12]
+    |       |   |       `--LITERAL_NULL -> null [42:21]
+    |       |   |--RPAREN -> ) [42:25]
+    |       |   `--SLIST -> { [42:27]
+    |       |       |--LITERAL_THROW -> throw [43:12]
+    |       |       |   |--EXPR -> EXPR [43:18]
+    |       |       |   |   `--LITERAL_NEW -> new [43:18]
+    |       |       |   |       |--IDENT -> NullPointerException [43:22]
+    |       |       |   |       |--LPAREN -> ( [43:42]
+    |       |       |   |       |--ELIST -> ELIST [43:43]
+    |       |       |   |       `--RPAREN -> ) [43:43]
+    |       |       |   `--SEMI -> ; [43:44]
+    |       |       `--RCURLY -> } [44:8]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [45:8]
+    |       |   |--MODIFIERS -> MODIFIERS [45:8]
+    |       |   |--TYPE -> TYPE [45:8]
+    |       |   |   |--IDENT -> String [45:8]
+    |       |   |   |--ANNOTATIONS -> ANNOTATIONS [45:20]
+    |       |   |   |   `--ANNOTATION -> ANNOTATION [45:20]
+    |       |   |   |       |--AT -> @ [45:20]
+    |       |   |   |       `--IDENT -> Nullable [45:21]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [45:30]
+    |       |   |       `--RBRACK -> ] [45:31]
+    |       |   `--IDENT -> tmp1 [45:15]
+    |       |--SEMI -> ; [45:32]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [46:8]
+    |       |   |--MODIFIERS -> MODIFIERS [46:8]
+    |       |   |   `--ANNOTATION -> ANNOTATION [46:8]
+    |       |   |       |--AT -> @ [46:8]
+    |       |   |       `--IDENT -> Nullable [46:9]
+    |       |   |--TYPE -> TYPE [46:18]
+    |       |   |   |--IDENT -> Object [46:18]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [46:24]
+    |       |   |       `--RBRACK -> ] [46:25]
+    |       |   |--IDENT -> tmp2 [46:27]
+    |       |   `--ASSIGN -> = [46:32]
+    |       |       `--EXPR -> EXPR [46:34]
+    |       |           `--LITERAL_NEW -> new [46:34]
+    |       |               |--ANNOTATIONS -> ANNOTATIONS [46:38]
+    |       |               |   `--ANNOTATION -> ANNOTATION [46:38]
+    |       |               |       |--AT -> @ [46:38]
+    |       |               |       `--IDENT -> Nullable [46:39]
+    |       |               |--IDENT -> Integer [46:48]
+    |       |               `--ARRAY_DECLARATOR -> [ [46:55]
+    |       |                   |--EXPR -> EXPR [46:56]
+    |       |                   |   `--NUM_INT -> 3 [46:56]
+    |       |                   `--RBRACK -> ] [46:57]
+    |       |--SEMI -> ; [46:58]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [47:8]
+    |       |   |--MODIFIERS -> MODIFIERS [47:8]
+    |       |   |   `--ANNOTATION -> ANNOTATION [47:8]
+    |       |   |       |--AT -> @ [47:8]
+    |       |   |       `--IDENT -> Nullable [47:9]
+    |       |   |--TYPE -> TYPE [47:18]
+    |       |   |   |--LITERAL_INT -> int [47:18]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [47:21]
+    |       |   |       `--RBRACK -> ] [47:22]
+    |       |   |--IDENT -> tmp3 [47:24]
+    |       |   `--ASSIGN -> = [47:29]
+    |       |       `--EXPR -> EXPR [47:31]
+    |       |           `--LITERAL_NEW -> new [47:31]
+    |       |               |--ANNOTATIONS -> ANNOTATIONS [47:35]
+    |       |               |   `--ANNOTATION -> ANNOTATION [47:35]
+    |       |               |       |--AT -> @ [47:35]
+    |       |               |       `--IDENT -> Nullable [47:36]
+    |       |               |--LITERAL_INT -> int [47:45]
+    |       |               `--ARRAY_DECLARATOR -> [ [47:48]
+    |       |                   |--EXPR -> EXPR [47:49]
+    |       |                   |   `--NUM_INT -> 3 [47:49]
+    |       |                   `--RBRACK -> ] [47:50]
+    |       |--SEMI -> ; [47:51]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [48:8]
+    |       |   |--MODIFIERS -> MODIFIERS [48:8]
+    |       |   |   `--ANNOTATION -> ANNOTATION [48:8]
+    |       |   |       |--AT -> @ [48:8]
+    |       |   |       `--IDENT -> Nullable [48:9]
+    |       |   |--TYPE -> TYPE [48:18]
+    |       |   |   `--IDENT -> Object [48:18]
+    |       |   |--IDENT -> tmp4 [48:25]
+    |       |   `--ASSIGN -> = [48:30]
+    |       |       `--EXPR -> EXPR [48:32]
+    |       |           `--LITERAL_NEW -> new [48:32]
+    |       |               |--ANNOTATIONS -> ANNOTATIONS [48:36]
+    |       |               |   `--ANNOTATION -> ANNOTATION [48:36]
+    |       |               |       |--AT -> @ [48:36]
+    |       |               |       `--IDENT -> Nullable [48:37]
+    |       |               |--IDENT -> String [48:46]
+    |       |               |--ANNOTATIONS -> ANNOTATIONS [48:53]
+    |       |               |   `--ANNOTATION -> ANNOTATION [48:53]
+    |       |               |       |--AT -> @ [48:53]
+    |       |               |       `--IDENT -> Nullable [48:54]
+    |       |               |--ARRAY_DECLARATOR -> [ [48:63]
+    |       |               |   |--EXPR -> EXPR [48:64]
+    |       |               |   |   `--NUM_INT -> 3 [48:64]
+    |       |               |   `--RBRACK -> ] [48:65]
+    |       |               |--ANNOTATIONS -> ANNOTATIONS [48:67]
+    |       |               |   `--ANNOTATION -> ANNOTATION [48:67]
+    |       |               |       |--AT -> @ [48:67]
+    |       |               |       `--IDENT -> Nullable [48:68]
+    |       |               `--ARRAY_DECLARATOR -> [ [48:77]
+    |       |                   |--EXPR -> EXPR [48:78]
+    |       |                   |   `--NUM_INT -> 2 [48:78]
+    |       |                   `--RBRACK -> ] [48:79]
+    |       |--SEMI -> ; [48:80]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [49:8]
+    |       |   |--MODIFIERS -> MODIFIERS [49:8]
+    |       |   |   `--ANNOTATION -> ANNOTATION [49:8]
+    |       |   |       |--AT -> @ [49:8]
+    |       |   |       `--IDENT -> Nullable [49:9]
+    |       |   |--TYPE -> TYPE [49:18]
+    |       |   |   `--IDENT -> Object [49:18]
+    |       |   |--IDENT -> tmp5 [49:25]
+    |       |   `--ASSIGN -> = [49:30]
+    |       |       `--EXPR -> EXPR [49:32]
+    |       |           `--LITERAL_NEW -> new [49:32]
+    |       |               |--ANNOTATIONS -> ANNOTATIONS [49:36]
+    |       |               |   `--ANNOTATION -> ANNOTATION [49:36]
+    |       |               |       |--AT -> @ [49:36]
+    |       |               |       `--IDENT -> Nullable [49:37]
+    |       |               |--LITERAL_INT -> int [49:46]
+    |       |               |--ANNOTATIONS -> ANNOTATIONS [49:50]
+    |       |               |   `--ANNOTATION -> ANNOTATION [49:50]
+    |       |               |       |--AT -> @ [49:50]
+    |       |               |       `--IDENT -> Nullable [49:51]
+    |       |               |--ARRAY_DECLARATOR -> [ [49:60]
+    |       |               |   |--EXPR -> EXPR [49:61]
+    |       |               |   |   `--NUM_INT -> 3 [49:61]
+    |       |               |   `--RBRACK -> ] [49:62]
+    |       |               |--ANNOTATIONS -> ANNOTATIONS [49:64]
+    |       |               |   `--ANNOTATION -> ANNOTATION [49:64]
+    |       |               |       |--AT -> @ [49:64]
+    |       |               |       `--IDENT -> Nullable [49:65]
+    |       |               `--ARRAY_DECLARATOR -> [ [49:74]
+    |       |                   |--EXPR -> EXPR [49:75]
+    |       |                   |   `--NUM_INT -> 2 [49:75]
+    |       |                   `--RBRACK -> ] [49:76]
+    |       |--SEMI -> ; [49:77]
+    |       |--LITERAL_RETURN -> return [51:8]
+    |       |   |--EXPR -> EXPR [51:15]
+    |       |   |   `--IDENT -> array [51:15]
+    |       |   `--SEMI -> ; [51:20]
+    |       `--RCURLY -> } [52:4]
+    `--RCURLY -> } [53:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnQualifiedTypes.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnQualifiedTypes.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnQualifiedTypes.java
@@ -0,0 +1,30 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import java.awt.geom.Rectangle2D;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+public class InputAntlr4AstRegressionAnnotationOnQualifiedTypes {
+    /* Causes parse failure */
+    Rectangle2D.@Ann Double rect = null;
+
+    /* Causes parse failure */
+    public final Rectangle2D.@Ann Double getRect1() {
+        return new Rectangle2D.Double();
+    }
+
+    /* Causes parse failure */
+    public final Rectangle2D.Double getRect2() {
+        return new Rectangle2D.@Ann Double();
+    }
+
+    /* Amazingly does not cause parse failure */
+    public final Rectangle2D.Double getRect3() {
+        Rectangle2D.@Ann Double rect = null;
+        return rect;
+    }
+}
+
+@Target({ ElementType.TYPE_USE })
+@interface Anno {
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnQualifiedTypes.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnQualifiedTypes.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnQualifiedTypes.txt
@@ -0,0 +1,172 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+IMPORT -> import [3:0]
+|--DOT -> . [3:20]
+|   |--DOT -> . [3:15]
+|   |   |--DOT -> . [3:11]
+|   |   |   |--IDENT -> java [3:7]
+|   |   |   `--IDENT -> awt [3:12]
+|   |   `--IDENT -> geom [3:16]
+|   `--IDENT -> Rectangle2D [3:21]
+`--SEMI -> ; [3:32]
+IMPORT -> import [4:0]
+|--DOT -> . [4:27]
+|   |--DOT -> . [4:16]
+|   |   |--DOT -> . [4:11]
+|   |   |   |--IDENT -> java [4:7]
+|   |   |   `--IDENT -> lang [4:12]
+|   |   `--IDENT -> annotation [4:17]
+|   `--IDENT -> ElementType [4:28]
+`--SEMI -> ; [4:39]
+IMPORT -> import [5:0]
+|--DOT -> . [5:27]
+|   |--DOT -> . [5:16]
+|   |   |--DOT -> . [5:11]
+|   |   |   |--IDENT -> java [5:7]
+|   |   |   `--IDENT -> lang [5:12]
+|   |   `--IDENT -> annotation [5:17]
+|   `--IDENT -> Target [5:28]
+`--SEMI -> ; [5:34]
+CLASS_DEF -> CLASS_DEF [7:0]
+|--MODIFIERS -> MODIFIERS [7:0]
+|   `--LITERAL_PUBLIC -> public [7:0]
+|--LITERAL_CLASS -> class [7:7]
+|--IDENT -> InputAntlr4AstRegressionAnnotationOnQualifiedTypes [7:13]
+`--OBJBLOCK -> OBJBLOCK [7:64]
+    |--LCURLY -> { [7:64]
+    |--VARIABLE_DEF -> VARIABLE_DEF [9:15]
+    |   |--MODIFIERS -> MODIFIERS [9:15]
+    |   |--TYPE -> TYPE [9:15]
+    |   |   `--DOT -> . [9:15]
+    |   |       |--IDENT -> Rectangle2D [9:4]
+    |   |       |--ANNOTATIONS -> ANNOTATIONS [9:16]
+    |   |       |   `--ANNOTATION -> ANNOTATION [9:16]
+    |   |       |       |--AT -> @ [9:16]
+    |   |       |       `--IDENT -> Ann [9:17]
+    |   |       `--IDENT -> Double [9:21]
+    |   |--IDENT -> rect [9:28]
+    |   |--ASSIGN -> = [9:33]
+    |   |   `--EXPR -> EXPR [9:35]
+    |   |       `--LITERAL_NULL -> null [9:35]
+    |   `--SEMI -> ; [9:39]
+    |--METHOD_DEF -> METHOD_DEF [12:4]
+    |   |--MODIFIERS -> MODIFIERS [12:4]
+    |   |   |--LITERAL_PUBLIC -> public [12:4]
+    |   |   `--FINAL -> final [12:11]
+    |   |--TYPE -> TYPE [12:28]
+    |   |   `--DOT -> . [12:28]
+    |   |       |--IDENT -> Rectangle2D [12:17]
+    |   |       |--ANNOTATIONS -> ANNOTATIONS [12:29]
+    |   |       |   `--ANNOTATION -> ANNOTATION [12:29]
+    |   |       |       |--AT -> @ [12:29]
+    |   |       |       `--IDENT -> Ann [12:30]
+    |   |       `--IDENT -> Double [12:34]
+    |   |--IDENT -> getRect1 [12:41]
+    |   |--LPAREN -> ( [12:49]
+    |   |--PARAMETERS -> PARAMETERS [12:50]
+    |   |--RPAREN -> ) [12:50]
+    |   `--SLIST -> { [12:52]
+    |       |--LITERAL_RETURN -> return [13:8]
+    |       |   |--EXPR -> EXPR [13:15]
+    |       |   |   `--LITERAL_NEW -> new [13:15]
+    |       |   |       |--DOT -> . [13:30]
+    |       |   |       |   |--IDENT -> Rectangle2D [13:19]
+    |       |   |       |   `--IDENT -> Double [13:31]
+    |       |   |       |--LPAREN -> ( [13:37]
+    |       |   |       |--ELIST -> ELIST [13:38]
+    |       |   |       `--RPAREN -> ) [13:38]
+    |       |   `--SEMI -> ; [13:39]
+    |       `--RCURLY -> } [14:4]
+    |--METHOD_DEF -> METHOD_DEF [17:4]
+    |   |--MODIFIERS -> MODIFIERS [17:4]
+    |   |   |--LITERAL_PUBLIC -> public [17:4]
+    |   |   `--FINAL -> final [17:11]
+    |   |--TYPE -> TYPE [17:28]
+    |   |   `--DOT -> . [17:28]
+    |   |       |--IDENT -> Rectangle2D [17:17]
+    |   |       `--IDENT -> Double [17:29]
+    |   |--IDENT -> getRect2 [17:36]
+    |   |--LPAREN -> ( [17:44]
+    |   |--PARAMETERS -> PARAMETERS [17:45]
+    |   |--RPAREN -> ) [17:45]
+    |   `--SLIST -> { [17:47]
+    |       |--LITERAL_RETURN -> return [18:8]
+    |       |   |--EXPR -> EXPR [18:15]
+    |       |   |   `--LITERAL_NEW -> new [18:15]
+    |       |   |       |--DOT -> . [18:30]
+    |       |   |       |   |--IDENT -> Rectangle2D [18:19]
+    |       |   |       |   |--ANNOTATIONS -> ANNOTATIONS [18:31]
+    |       |   |       |   |   `--ANNOTATION -> ANNOTATION [18:31]
+    |       |   |       |   |       |--AT -> @ [18:31]
+    |       |   |       |   |       `--IDENT -> Ann [18:32]
+    |       |   |       |   `--IDENT -> Double [18:36]
+    |       |   |       |--LPAREN -> ( [18:42]
+    |       |   |       |--ELIST -> ELIST [18:43]
+    |       |   |       `--RPAREN -> ) [18:43]
+    |       |   `--SEMI -> ; [18:44]
+    |       `--RCURLY -> } [19:4]
+    |--METHOD_DEF -> METHOD_DEF [22:4]
+    |   |--MODIFIERS -> MODIFIERS [22:4]
+    |   |   |--LITERAL_PUBLIC -> public [22:4]
+    |   |   `--FINAL -> final [22:11]
+    |   |--TYPE -> TYPE [22:28]
+    |   |   `--DOT -> . [22:28]
+    |   |       |--IDENT -> Rectangle2D [22:17]
+    |   |       `--IDENT -> Double [22:29]
+    |   |--IDENT -> getRect3 [22:36]
+    |   |--LPAREN -> ( [22:44]
+    |   |--PARAMETERS -> PARAMETERS [22:45]
+    |   |--RPAREN -> ) [22:45]
+    |   `--SLIST -> { [22:47]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [23:19]
+    |       |   |--MODIFIERS -> MODIFIERS [23:19]
+    |       |   |--TYPE -> TYPE [23:19]
+    |       |   |   `--DOT -> . [23:19]
+    |       |   |       |--IDENT -> Rectangle2D [23:8]
+    |       |   |       |--ANNOTATIONS -> ANNOTATIONS [23:20]
+    |       |   |       |   `--ANNOTATION -> ANNOTATION [23:20]
+    |       |   |       |       |--AT -> @ [23:20]
+    |       |   |       |       `--IDENT -> Ann [23:21]
+    |       |   |       `--IDENT -> Double [23:25]
+    |       |   |--IDENT -> rect [23:32]
+    |       |   `--ASSIGN -> = [23:37]
+    |       |       `--EXPR -> EXPR [23:39]
+    |       |           `--LITERAL_NULL -> null [23:39]
+    |       |--SEMI -> ; [23:43]
+    |       |--LITERAL_RETURN -> return [24:8]
+    |       |   |--EXPR -> EXPR [24:15]
+    |       |   |   `--IDENT -> rect [24:15]
+    |       |   `--SEMI -> ; [24:19]
+    |       `--RCURLY -> } [25:4]
+    `--RCURLY -> } [26:0]
+ANNOTATION_DEF -> ANNOTATION_DEF [28:0]
+|--MODIFIERS -> MODIFIERS [28:0]
+|   `--ANNOTATION -> ANNOTATION [28:0]
+|       |--AT -> @ [28:0]
+|       |--IDENT -> Target [28:1]
+|       |--LPAREN -> ( [28:7]
+|       |--ANNOTATION_ARRAY_INIT -> { [28:8]
+|       |   |--EXPR -> EXPR [28:21]
+|       |   |   `--DOT -> . [28:21]
+|       |   |       |--IDENT -> ElementType [28:10]
+|       |   |       `--IDENT -> TYPE_USE [28:22]
+|       |   `--RCURLY -> } [28:31]
+|       `--RPAREN -> ) [28:32]
+|--AT -> @ [29:0]
+|--LITERAL_INTERFACE -> interface [29:1]
+|--IDENT -> Anno [29:11]
+`--OBJBLOCK -> OBJBLOCK [29:16]
+    |--LCURLY -> { [29:16]
+    `--RCURLY -> } [30:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnSameLine.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnSameLine.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnSameLine.java
@@ -0,0 +1,38 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.PARAMETER;
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.ElementType.TYPE_PARAMETER;
+import static java.lang.annotation.ElementType.TYPE_USE;
+
+import java.lang.annotation.Target;
+import java.util.ArrayList;
+import java.util.List;
+
+public class InputAntlr4AstRegressionAnnotationOnSameLine {
+    @Ann        // ok
+    private List<String> names = new ArrayList<>();
+
+    @Ann private List<String> names2 = new ArrayList<>();       // violation
+
+    @SuppressWarnings("deprecation")        // violation
+    @Ann Integer x;
+
+    @SuppressWarnings("deprecation")        // violation
+    @Ann                                    // violation
+    Integer x2;
+
+    @SuppressWarnings("deprecation") @Ann @Ann2 @Ann3 @Ann4 Integer x3;     // ok
+
+}
+
+@Target({CONSTRUCTOR, FIELD, METHOD, PARAMETER, TYPE, TYPE_PARAMETER, TYPE_USE}) @interface Ann {}
+
+@Target({CONSTRUCTOR, FIELD, METHOD, PARAMETER, TYPE, TYPE_PARAMETER, TYPE_USE}) @interface Ann2 {}
+
+@interface Ann3 {}
+
+@interface Ann4 {}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnSameLine.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnSameLine.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnSameLine.txt
@@ -0,0 +1,322 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+STATIC_IMPORT -> import [3:0]
+|--LITERAL_STATIC -> static [3:7]
+|--DOT -> . [3:46]
+|   |--DOT -> . [3:34]
+|   |   |--DOT -> . [3:23]
+|   |   |   |--DOT -> . [3:18]
+|   |   |   |   |--IDENT -> java [3:14]
+|   |   |   |   `--IDENT -> lang [3:19]
+|   |   |   `--IDENT -> annotation [3:24]
+|   |   `--IDENT -> ElementType [3:35]
+|   `--IDENT -> CONSTRUCTOR [3:47]
+`--SEMI -> ; [3:58]
+STATIC_IMPORT -> import [4:0]
+|--LITERAL_STATIC -> static [4:7]
+|--DOT -> . [4:46]
+|   |--DOT -> . [4:34]
+|   |   |--DOT -> . [4:23]
+|   |   |   |--DOT -> . [4:18]
+|   |   |   |   |--IDENT -> java [4:14]
+|   |   |   |   `--IDENT -> lang [4:19]
+|   |   |   `--IDENT -> annotation [4:24]
+|   |   `--IDENT -> ElementType [4:35]
+|   `--IDENT -> FIELD [4:47]
+`--SEMI -> ; [4:52]
+STATIC_IMPORT -> import [5:0]
+|--LITERAL_STATIC -> static [5:7]
+|--DOT -> . [5:46]
+|   |--DOT -> . [5:34]
+|   |   |--DOT -> . [5:23]
+|   |   |   |--DOT -> . [5:18]
+|   |   |   |   |--IDENT -> java [5:14]
+|   |   |   |   `--IDENT -> lang [5:19]
+|   |   |   `--IDENT -> annotation [5:24]
+|   |   `--IDENT -> ElementType [5:35]
+|   `--IDENT -> METHOD [5:47]
+`--SEMI -> ; [5:53]
+STATIC_IMPORT -> import [6:0]
+|--LITERAL_STATIC -> static [6:7]
+|--DOT -> . [6:46]
+|   |--DOT -> . [6:34]
+|   |   |--DOT -> . [6:23]
+|   |   |   |--DOT -> . [6:18]
+|   |   |   |   |--IDENT -> java [6:14]
+|   |   |   |   `--IDENT -> lang [6:19]
+|   |   |   `--IDENT -> annotation [6:24]
+|   |   `--IDENT -> ElementType [6:35]
+|   `--IDENT -> PARAMETER [6:47]
+`--SEMI -> ; [6:56]
+STATIC_IMPORT -> import [7:0]
+|--LITERAL_STATIC -> static [7:7]
+|--DOT -> . [7:46]
+|   |--DOT -> . [7:34]
+|   |   |--DOT -> . [7:23]
+|   |   |   |--DOT -> . [7:18]
+|   |   |   |   |--IDENT -> java [7:14]
+|   |   |   |   `--IDENT -> lang [7:19]
+|   |   |   `--IDENT -> annotation [7:24]
+|   |   `--IDENT -> ElementType [7:35]
+|   `--IDENT -> TYPE [7:47]
+`--SEMI -> ; [7:51]
+STATIC_IMPORT -> import [8:0]
+|--LITERAL_STATIC -> static [8:7]
+|--DOT -> . [8:46]
+|   |--DOT -> . [8:34]
+|   |   |--DOT -> . [8:23]
+|   |   |   |--DOT -> . [8:18]
+|   |   |   |   |--IDENT -> java [8:14]
+|   |   |   |   `--IDENT -> lang [8:19]
+|   |   |   `--IDENT -> annotation [8:24]
+|   |   `--IDENT -> ElementType [8:35]
+|   `--IDENT -> TYPE_PARAMETER [8:47]
+`--SEMI -> ; [8:61]
+STATIC_IMPORT -> import [9:0]
+|--LITERAL_STATIC -> static [9:7]
+|--DOT -> . [9:46]
+|   |--DOT -> . [9:34]
+|   |   |--DOT -> . [9:23]
+|   |   |   |--DOT -> . [9:18]
+|   |   |   |   |--IDENT -> java [9:14]
+|   |   |   |   `--IDENT -> lang [9:19]
+|   |   |   `--IDENT -> annotation [9:24]
+|   |   `--IDENT -> ElementType [9:35]
+|   `--IDENT -> TYPE_USE [9:47]
+`--SEMI -> ; [9:55]
+IMPORT -> import [11:0]
+|--DOT -> . [11:27]
+|   |--DOT -> . [11:16]
+|   |   |--DOT -> . [11:11]
+|   |   |   |--IDENT -> java [11:7]
+|   |   |   `--IDENT -> lang [11:12]
+|   |   `--IDENT -> annotation [11:17]
+|   `--IDENT -> Target [11:28]
+`--SEMI -> ; [11:34]
+IMPORT -> import [12:0]
+|--DOT -> . [12:16]
+|   |--DOT -> . [12:11]
+|   |   |--IDENT -> java [12:7]
+|   |   `--IDENT -> util [12:12]
+|   `--IDENT -> ArrayList [12:17]
+`--SEMI -> ; [12:26]
+IMPORT -> import [13:0]
+|--DOT -> . [13:16]
+|   |--DOT -> . [13:11]
+|   |   |--IDENT -> java [13:7]
+|   |   `--IDENT -> util [13:12]
+|   `--IDENT -> List [13:17]
+`--SEMI -> ; [13:21]
+CLASS_DEF -> CLASS_DEF [15:0]
+|--MODIFIERS -> MODIFIERS [15:0]
+|   `--LITERAL_PUBLIC -> public [15:0]
+|--LITERAL_CLASS -> class [15:7]
+|--IDENT -> InputAntlr4AstRegressionAnnotationOnSameLine [15:13]
+`--OBJBLOCK -> OBJBLOCK [15:58]
+    |--LCURLY -> { [15:58]
+    |--VARIABLE_DEF -> VARIABLE_DEF [16:4]
+    |   |--MODIFIERS -> MODIFIERS [16:4]
+    |   |   |--ANNOTATION -> ANNOTATION [16:4]
+    |   |   |   |--AT -> @ [16:4]
+    |   |   |   `--IDENT -> Ann [16:5]
+    |   |   `--LITERAL_PRIVATE -> private [17:4]
+    |   |--TYPE -> TYPE [17:12]
+    |   |   |--IDENT -> List [17:12]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [17:16]
+    |   |       |--GENERIC_START -> < [17:16]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [17:17]
+    |   |       |   `--IDENT -> String [17:17]
+    |   |       `--GENERIC_END -> > [17:23]
+    |   |--IDENT -> names [17:25]
+    |   |--ASSIGN -> = [17:31]
+    |   |   `--EXPR -> EXPR [17:33]
+    |   |       `--LITERAL_NEW -> new [17:33]
+    |   |           |--IDENT -> ArrayList [17:37]
+    |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [17:46]
+    |   |           |   |--GENERIC_START -> < [17:46]
+    |   |           |   `--GENERIC_END -> > [17:47]
+    |   |           |--LPAREN -> ( [17:48]
+    |   |           |--ELIST -> ELIST [17:49]
+    |   |           `--RPAREN -> ) [17:49]
+    |   `--SEMI -> ; [17:50]
+    |--VARIABLE_DEF -> VARIABLE_DEF [19:4]
+    |   |--MODIFIERS -> MODIFIERS [19:4]
+    |   |   |--ANNOTATION -> ANNOTATION [19:4]
+    |   |   |   |--AT -> @ [19:4]
+    |   |   |   `--IDENT -> Ann [19:5]
+    |   |   `--LITERAL_PRIVATE -> private [19:9]
+    |   |--TYPE -> TYPE [19:17]
+    |   |   |--IDENT -> List [19:17]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [19:21]
+    |   |       |--GENERIC_START -> < [19:21]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [19:22]
+    |   |       |   `--IDENT -> String [19:22]
+    |   |       `--GENERIC_END -> > [19:28]
+    |   |--IDENT -> names2 [19:30]
+    |   |--ASSIGN -> = [19:37]
+    |   |   `--EXPR -> EXPR [19:39]
+    |   |       `--LITERAL_NEW -> new [19:39]
+    |   |           |--IDENT -> ArrayList [19:43]
+    |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [19:52]
+    |   |           |   |--GENERIC_START -> < [19:52]
+    |   |           |   `--GENERIC_END -> > [19:53]
+    |   |           |--LPAREN -> ( [19:54]
+    |   |           |--ELIST -> ELIST [19:55]
+    |   |           `--RPAREN -> ) [19:55]
+    |   `--SEMI -> ; [19:56]
+    |--VARIABLE_DEF -> VARIABLE_DEF [21:4]
+    |   |--MODIFIERS -> MODIFIERS [21:4]
+    |   |   |--ANNOTATION -> ANNOTATION [21:4]
+    |   |   |   |--AT -> @ [21:4]
+    |   |   |   |--IDENT -> SuppressWarnings [21:5]
+    |   |   |   |--LPAREN -> ( [21:21]
+    |   |   |   |--EXPR -> EXPR [21:22]
+    |   |   |   |   `--STRING_LITERAL -> "deprecation" [21:22]
+    |   |   |   `--RPAREN -> ) [21:35]
+    |   |   `--ANNOTATION -> ANNOTATION [22:4]
+    |   |       |--AT -> @ [22:4]
+    |   |       `--IDENT -> Ann [22:5]
+    |   |--TYPE -> TYPE [22:9]
+    |   |   `--IDENT -> Integer [22:9]
+    |   |--IDENT -> x [22:17]
+    |   `--SEMI -> ; [22:18]
+    |--VARIABLE_DEF -> VARIABLE_DEF [24:4]
+    |   |--MODIFIERS -> MODIFIERS [24:4]
+    |   |   |--ANNOTATION -> ANNOTATION [24:4]
+    |   |   |   |--AT -> @ [24:4]
+    |   |   |   |--IDENT -> SuppressWarnings [24:5]
+    |   |   |   |--LPAREN -> ( [24:21]
+    |   |   |   |--EXPR -> EXPR [24:22]
+    |   |   |   |   `--STRING_LITERAL -> "deprecation" [24:22]
+    |   |   |   `--RPAREN -> ) [24:35]
+    |   |   `--ANNOTATION -> ANNOTATION [25:4]
+    |   |       |--AT -> @ [25:4]
+    |   |       `--IDENT -> Ann [25:5]
+    |   |--TYPE -> TYPE [26:4]
+    |   |   `--IDENT -> Integer [26:4]
+    |   |--IDENT -> x2 [26:12]
+    |   `--SEMI -> ; [26:14]
+    |--VARIABLE_DEF -> VARIABLE_DEF [28:4]
+    |   |--MODIFIERS -> MODIFIERS [28:4]
+    |   |   |--ANNOTATION -> ANNOTATION [28:4]
+    |   |   |   |--AT -> @ [28:4]
+    |   |   |   |--IDENT -> SuppressWarnings [28:5]
+    |   |   |   |--LPAREN -> ( [28:21]
+    |   |   |   |--EXPR -> EXPR [28:22]
+    |   |   |   |   `--STRING_LITERAL -> "deprecation" [28:22]
+    |   |   |   `--RPAREN -> ) [28:35]
+    |   |   |--ANNOTATION -> ANNOTATION [28:37]
+    |   |   |   |--AT -> @ [28:37]
+    |   |   |   `--IDENT -> Ann [28:38]
+    |   |   |--ANNOTATION -> ANNOTATION [28:42]
+    |   |   |   |--AT -> @ [28:42]
+    |   |   |   `--IDENT -> Ann2 [28:43]
+    |   |   |--ANNOTATION -> ANNOTATION [28:48]
+    |   |   |   |--AT -> @ [28:48]
+    |   |   |   `--IDENT -> Ann3 [28:49]
+    |   |   `--ANNOTATION -> ANNOTATION [28:54]
+    |   |       |--AT -> @ [28:54]
+    |   |       `--IDENT -> Ann4 [28:55]
+    |   |--TYPE -> TYPE [28:60]
+    |   |   `--IDENT -> Integer [28:60]
+    |   |--IDENT -> x3 [28:68]
+    |   `--SEMI -> ; [28:70]
+    `--RCURLY -> } [30:0]
+ANNOTATION_DEF -> ANNOTATION_DEF [32:0]
+|--MODIFIERS -> MODIFIERS [32:0]
+|   `--ANNOTATION -> ANNOTATION [32:0]
+|       |--AT -> @ [32:0]
+|       |--IDENT -> Target [32:1]
+|       |--LPAREN -> ( [32:7]
+|       |--ANNOTATION_ARRAY_INIT -> { [32:8]
+|       |   |--EXPR -> EXPR [32:9]
+|       |   |   `--IDENT -> CONSTRUCTOR [32:9]
+|       |   |--COMMA -> , [32:20]
+|       |   |--EXPR -> EXPR [32:22]
+|       |   |   `--IDENT -> FIELD [32:22]
+|       |   |--COMMA -> , [32:27]
+|       |   |--EXPR -> EXPR [32:29]
+|       |   |   `--IDENT -> METHOD [32:29]
+|       |   |--COMMA -> , [32:35]
+|       |   |--EXPR -> EXPR [32:37]
+|       |   |   `--IDENT -> PARAMETER [32:37]
+|       |   |--COMMA -> , [32:46]
+|       |   |--EXPR -> EXPR [32:48]
+|       |   |   `--IDENT -> TYPE [32:48]
+|       |   |--COMMA -> , [32:52]
+|       |   |--EXPR -> EXPR [32:54]
+|       |   |   `--IDENT -> TYPE_PARAMETER [32:54]
+|       |   |--COMMA -> , [32:68]
+|       |   |--EXPR -> EXPR [32:70]
+|       |   |   `--IDENT -> TYPE_USE [32:70]
+|       |   `--RCURLY -> } [32:78]
+|       `--RPAREN -> ) [32:79]
+|--AT -> @ [32:81]
+|--LITERAL_INTERFACE -> interface [32:82]
+|--IDENT -> Ann [32:92]
+`--OBJBLOCK -> OBJBLOCK [32:96]
+    |--LCURLY -> { [32:96]
+    `--RCURLY -> } [32:97]
+ANNOTATION_DEF -> ANNOTATION_DEF [34:0]
+|--MODIFIERS -> MODIFIERS [34:0]
+|   `--ANNOTATION -> ANNOTATION [34:0]
+|       |--AT -> @ [34:0]
+|       |--IDENT -> Target [34:1]
+|       |--LPAREN -> ( [34:7]
+|       |--ANNOTATION_ARRAY_INIT -> { [34:8]
+|       |   |--EXPR -> EXPR [34:9]
+|       |   |   `--IDENT -> CONSTRUCTOR [34:9]
+|       |   |--COMMA -> , [34:20]
+|       |   |--EXPR -> EXPR [34:22]
+|       |   |   `--IDENT -> FIELD [34:22]
+|       |   |--COMMA -> , [34:27]
+|       |   |--EXPR -> EXPR [34:29]
+|       |   |   `--IDENT -> METHOD [34:29]
+|       |   |--COMMA -> , [34:35]
+|       |   |--EXPR -> EXPR [34:37]
+|       |   |   `--IDENT -> PARAMETER [34:37]
+|       |   |--COMMA -> , [34:46]
+|       |   |--EXPR -> EXPR [34:48]
+|       |   |   `--IDENT -> TYPE [34:48]
+|       |   |--COMMA -> , [34:52]
+|       |   |--EXPR -> EXPR [34:54]
+|       |   |   `--IDENT -> TYPE_PARAMETER [34:54]
+|       |   |--COMMA -> , [34:68]
+|       |   |--EXPR -> EXPR [34:70]
+|       |   |   `--IDENT -> TYPE_USE [34:70]
+|       |   `--RCURLY -> } [34:78]
+|       `--RPAREN -> ) [34:79]
+|--AT -> @ [34:81]
+|--LITERAL_INTERFACE -> interface [34:82]
+|--IDENT -> Ann2 [34:92]
+`--OBJBLOCK -> OBJBLOCK [34:97]
+    |--LCURLY -> { [34:97]
+    `--RCURLY -> } [34:98]
+ANNOTATION_DEF -> ANNOTATION_DEF [36:0]
+|--MODIFIERS -> MODIFIERS [36:0]
+|--AT -> @ [36:0]
+|--LITERAL_INTERFACE -> interface [36:1]
+|--IDENT -> Ann3 [36:11]
+`--OBJBLOCK -> OBJBLOCK [36:16]
+    |--LCURLY -> { [36:16]
+    `--RCURLY -> } [36:17]
+ANNOTATION_DEF -> ANNOTATION_DEF [38:0]
+|--MODIFIERS -> MODIFIERS [38:0]
+|--AT -> @ [38:0]
+|--LITERAL_INTERFACE -> interface [38:1]
+|--IDENT -> Ann4 [38:11]
+`--OBJBLOCK -> OBJBLOCK [38:16]
+    |--LCURLY -> { [38:16]
+    `--RCURLY -> } [38:17]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnSameLine2.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnSameLine2.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnSameLine2.java
@@ -0,0 +1,103 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+public class InputAntlr4AstRegressionAnnotationOnSameLine2 {
+        /**
+         * @deprecated bleh
+         * @deprecated boo
+         */
+        public int i;
+
+        /**
+         * @deprecated
+         */
+        public void foo() {
+
+        }
+
+        /**
+         * @deprecated
+         */
+        @Deprecated
+        public void foo2() {
+
+        }
+
+        /**
+         * @deprecated
+         * @deprecated
+         */
+        @Deprecated
+        public void foo3() {
+
+        }
+
+        /**
+         * @deprecated bleh
+         * @deprecated
+         */
+        @Deprecated
+        public void foo4() {
+
+        }
+
+        /**
+         * @deprecated
+         * @deprecated bleh
+         */
+        @Deprecated
+        public void foo5() {
+
+        }
+
+        void local(@Deprecated String s) {
+
+        }
+
+        void local2(
+            /** @deprecated bleh*/
+            String s) {
+
+        }
+
+        void local3(/** @deprecated */ @Deprecated String s) {
+
+        }
+
+        /**
+         * @Deprecated
+         */
+        void dontUse() {
+
+        }
+
+        /**
+         * @Deprecated
+         * @deprecated
+         *  because I said.
+         */
+        @Deprecated
+        void dontUse2() {
+
+        }
+
+        /**
+         * @deprecated
+         */
+        int[] dontUse3() {
+            return null;
+        }
+
+        /**
+         * @deprecated
+         */
+        <T> T dontUse4() {
+            return null;
+        }
+
+        /**
+         * @deprecated
+         */
+        java.lang.String dontUse5() {
+            return null;
+        }
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnSameLine2.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnSameLine2.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionAnnotationOnSameLine2.txt
@@ -0,0 +1,223 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+CLASS_DEF -> CLASS_DEF [3:0]
+|--MODIFIERS -> MODIFIERS [3:0]
+|   `--LITERAL_PUBLIC -> public [3:0]
+|--LITERAL_CLASS -> class [3:7]
+|--IDENT -> InputAntlr4AstRegressionAnnotationOnSameLine2 [3:13]
+`--OBJBLOCK -> OBJBLOCK [3:59]
+    |--LCURLY -> { [3:59]
+    |--VARIABLE_DEF -> VARIABLE_DEF [8:8]
+    |   |--MODIFIERS -> MODIFIERS [8:8]
+    |   |   `--LITERAL_PUBLIC -> public [8:8]
+    |   |--TYPE -> TYPE [8:15]
+    |   |   `--LITERAL_INT -> int [8:15]
+    |   |--IDENT -> i [8:19]
+    |   `--SEMI -> ; [8:20]
+    |--METHOD_DEF -> METHOD_DEF [13:8]
+    |   |--MODIFIERS -> MODIFIERS [13:8]
+    |   |   `--LITERAL_PUBLIC -> public [13:8]
+    |   |--TYPE -> TYPE [13:15]
+    |   |   `--LITERAL_VOID -> void [13:15]
+    |   |--IDENT -> foo [13:20]
+    |   |--LPAREN -> ( [13:23]
+    |   |--PARAMETERS -> PARAMETERS [13:24]
+    |   |--RPAREN -> ) [13:24]
+    |   `--SLIST -> { [13:26]
+    |       `--RCURLY -> } [15:8]
+    |--METHOD_DEF -> METHOD_DEF [20:8]
+    |   |--MODIFIERS -> MODIFIERS [20:8]
+    |   |   |--ANNOTATION -> ANNOTATION [20:8]
+    |   |   |   |--AT -> @ [20:8]
+    |   |   |   `--IDENT -> Deprecated [20:9]
+    |   |   `--LITERAL_PUBLIC -> public [21:8]
+    |   |--TYPE -> TYPE [21:15]
+    |   |   `--LITERAL_VOID -> void [21:15]
+    |   |--IDENT -> foo2 [21:20]
+    |   |--LPAREN -> ( [21:24]
+    |   |--PARAMETERS -> PARAMETERS [21:25]
+    |   |--RPAREN -> ) [21:25]
+    |   `--SLIST -> { [21:27]
+    |       `--RCURLY -> } [23:8]
+    |--METHOD_DEF -> METHOD_DEF [29:8]
+    |   |--MODIFIERS -> MODIFIERS [29:8]
+    |   |   |--ANNOTATION -> ANNOTATION [29:8]
+    |   |   |   |--AT -> @ [29:8]
+    |   |   |   `--IDENT -> Deprecated [29:9]
+    |   |   `--LITERAL_PUBLIC -> public [30:8]
+    |   |--TYPE -> TYPE [30:15]
+    |   |   `--LITERAL_VOID -> void [30:15]
+    |   |--IDENT -> foo3 [30:20]
+    |   |--LPAREN -> ( [30:24]
+    |   |--PARAMETERS -> PARAMETERS [30:25]
+    |   |--RPAREN -> ) [30:25]
+    |   `--SLIST -> { [30:27]
+    |       `--RCURLY -> } [32:8]
+    |--METHOD_DEF -> METHOD_DEF [38:8]
+    |   |--MODIFIERS -> MODIFIERS [38:8]
+    |   |   |--ANNOTATION -> ANNOTATION [38:8]
+    |   |   |   |--AT -> @ [38:8]
+    |   |   |   `--IDENT -> Deprecated [38:9]
+    |   |   `--LITERAL_PUBLIC -> public [39:8]
+    |   |--TYPE -> TYPE [39:15]
+    |   |   `--LITERAL_VOID -> void [39:15]
+    |   |--IDENT -> foo4 [39:20]
+    |   |--LPAREN -> ( [39:24]
+    |   |--PARAMETERS -> PARAMETERS [39:25]
+    |   |--RPAREN -> ) [39:25]
+    |   `--SLIST -> { [39:27]
+    |       `--RCURLY -> } [41:8]
+    |--METHOD_DEF -> METHOD_DEF [47:8]
+    |   |--MODIFIERS -> MODIFIERS [47:8]
+    |   |   |--ANNOTATION -> ANNOTATION [47:8]
+    |   |   |   |--AT -> @ [47:8]
+    |   |   |   `--IDENT -> Deprecated [47:9]
+    |   |   `--LITERAL_PUBLIC -> public [48:8]
+    |   |--TYPE -> TYPE [48:15]
+    |   |   `--LITERAL_VOID -> void [48:15]
+    |   |--IDENT -> foo5 [48:20]
+    |   |--LPAREN -> ( [48:24]
+    |   |--PARAMETERS -> PARAMETERS [48:25]
+    |   |--RPAREN -> ) [48:25]
+    |   `--SLIST -> { [48:27]
+    |       `--RCURLY -> } [50:8]
+    |--METHOD_DEF -> METHOD_DEF [52:8]
+    |   |--MODIFIERS -> MODIFIERS [52:8]
+    |   |--TYPE -> TYPE [52:8]
+    |   |   `--LITERAL_VOID -> void [52:8]
+    |   |--IDENT -> local [52:13]
+    |   |--LPAREN -> ( [52:18]
+    |   |--PARAMETERS -> PARAMETERS [52:19]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [52:19]
+    |   |       |--MODIFIERS -> MODIFIERS [52:19]
+    |   |       |   `--ANNOTATION -> ANNOTATION [52:19]
+    |   |       |       |--AT -> @ [52:19]
+    |   |       |       `--IDENT -> Deprecated [52:20]
+    |   |       |--TYPE -> TYPE [52:31]
+    |   |       |   `--IDENT -> String [52:31]
+    |   |       `--IDENT -> s [52:38]
+    |   |--RPAREN -> ) [52:39]
+    |   `--SLIST -> { [52:41]
+    |       `--RCURLY -> } [54:8]
+    |--METHOD_DEF -> METHOD_DEF [56:8]
+    |   |--MODIFIERS -> MODIFIERS [56:8]
+    |   |--TYPE -> TYPE [56:8]
+    |   |   `--LITERAL_VOID -> void [56:8]
+    |   |--IDENT -> local2 [56:13]
+    |   |--LPAREN -> ( [56:19]
+    |   |--PARAMETERS -> PARAMETERS [58:12]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [58:12]
+    |   |       |--MODIFIERS -> MODIFIERS [58:12]
+    |   |       |--TYPE -> TYPE [58:12]
+    |   |       |   `--IDENT -> String [58:12]
+    |   |       `--IDENT -> s [58:19]
+    |   |--RPAREN -> ) [58:20]
+    |   `--SLIST -> { [58:22]
+    |       `--RCURLY -> } [60:8]
+    |--METHOD_DEF -> METHOD_DEF [62:8]
+    |   |--MODIFIERS -> MODIFIERS [62:8]
+    |   |--TYPE -> TYPE [62:8]
+    |   |   `--LITERAL_VOID -> void [62:8]
+    |   |--IDENT -> local3 [62:13]
+    |   |--LPAREN -> ( [62:19]
+    |   |--PARAMETERS -> PARAMETERS [62:39]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [62:39]
+    |   |       |--MODIFIERS -> MODIFIERS [62:39]
+    |   |       |   `--ANNOTATION -> ANNOTATION [62:39]
+    |   |       |       |--AT -> @ [62:39]
+    |   |       |       `--IDENT -> Deprecated [62:40]
+    |   |       |--TYPE -> TYPE [62:51]
+    |   |       |   `--IDENT -> String [62:51]
+    |   |       `--IDENT -> s [62:58]
+    |   |--RPAREN -> ) [62:59]
+    |   `--SLIST -> { [62:61]
+    |       `--RCURLY -> } [64:8]
+    |--METHOD_DEF -> METHOD_DEF [69:8]
+    |   |--MODIFIERS -> MODIFIERS [69:8]
+    |   |--TYPE -> TYPE [69:8]
+    |   |   `--LITERAL_VOID -> void [69:8]
+    |   |--IDENT -> dontUse [69:13]
+    |   |--LPAREN -> ( [69:20]
+    |   |--PARAMETERS -> PARAMETERS [69:21]
+    |   |--RPAREN -> ) [69:21]
+    |   `--SLIST -> { [69:23]
+    |       `--RCURLY -> } [71:8]
+    |--METHOD_DEF -> METHOD_DEF [78:8]
+    |   |--MODIFIERS -> MODIFIERS [78:8]
+    |   |   `--ANNOTATION -> ANNOTATION [78:8]
+    |   |       |--AT -> @ [78:8]
+    |   |       `--IDENT -> Deprecated [78:9]
+    |   |--TYPE -> TYPE [79:8]
+    |   |   `--LITERAL_VOID -> void [79:8]
+    |   |--IDENT -> dontUse2 [79:13]
+    |   |--LPAREN -> ( [79:21]
+    |   |--PARAMETERS -> PARAMETERS [79:22]
+    |   |--RPAREN -> ) [79:22]
+    |   `--SLIST -> { [79:24]
+    |       `--RCURLY -> } [81:8]
+    |--METHOD_DEF -> METHOD_DEF [86:8]
+    |   |--MODIFIERS -> MODIFIERS [86:8]
+    |   |--TYPE -> TYPE [86:8]
+    |   |   |--LITERAL_INT -> int [86:8]
+    |   |   `--ARRAY_DECLARATOR -> [ [86:11]
+    |   |       `--RBRACK -> ] [86:12]
+    |   |--IDENT -> dontUse3 [86:14]
+    |   |--LPAREN -> ( [86:22]
+    |   |--PARAMETERS -> PARAMETERS [86:23]
+    |   |--RPAREN -> ) [86:23]
+    |   `--SLIST -> { [86:25]
+    |       |--LITERAL_RETURN -> return [87:12]
+    |       |   |--EXPR -> EXPR [87:19]
+    |       |   |   `--LITERAL_NULL -> null [87:19]
+    |       |   `--SEMI -> ; [87:23]
+    |       `--RCURLY -> } [88:8]
+    |--METHOD_DEF -> METHOD_DEF [93:8]
+    |   |--MODIFIERS -> MODIFIERS [93:8]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [93:8]
+    |   |   |--GENERIC_START -> < [93:8]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [93:9]
+    |   |   |   `--IDENT -> T [93:9]
+    |   |   `--GENERIC_END -> > [93:10]
+    |   |--TYPE -> TYPE [93:12]
+    |   |   `--IDENT -> T [93:12]
+    |   |--IDENT -> dontUse4 [93:14]
+    |   |--LPAREN -> ( [93:22]
+    |   |--PARAMETERS -> PARAMETERS [93:23]
+    |   |--RPAREN -> ) [93:23]
+    |   `--SLIST -> { [93:25]
+    |       |--LITERAL_RETURN -> return [94:12]
+    |       |   |--EXPR -> EXPR [94:19]
+    |       |   |   `--LITERAL_NULL -> null [94:19]
+    |       |   `--SEMI -> ; [94:23]
+    |       `--RCURLY -> } [95:8]
+    |--METHOD_DEF -> METHOD_DEF [100:17]
+    |   |--MODIFIERS -> MODIFIERS [100:17]
+    |   |--TYPE -> TYPE [100:17]
+    |   |   `--DOT -> . [100:17]
+    |   |       |--DOT -> . [100:12]
+    |   |       |   |--IDENT -> java [100:8]
+    |   |       |   `--IDENT -> lang [100:13]
+    |   |       `--IDENT -> String [100:18]
+    |   |--IDENT -> dontUse5 [100:25]
+    |   |--LPAREN -> ( [100:33]
+    |   |--PARAMETERS -> PARAMETERS [100:34]
+    |   |--RPAREN -> ) [100:34]
+    |   `--SLIST -> { [100:36]
+    |       |--LITERAL_RETURN -> return [101:12]
+    |       |   |--EXPR -> EXPR [101:19]
+    |       |   |   `--LITERAL_NULL -> null [101:19]
+    |       |   `--SEMI -> ; [101:23]
+    |       `--RCURLY -> } [102:8]
+    `--RCURLY -> } [103:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionBadOverride.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionBadOverride.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionBadOverride.java
@@ -0,0 +1,61 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import java.io.Serializable;
+
+public class InputAntlr4AstRegressionBadOverride {
+   /**
+     * {@inheritDoc}
+     */
+    public void doFoo() {}      // violation
+
+    public void doFoo2() {}
+
+}
+
+interface IFoo2 {
+
+    void doFoo();
+}
+
+interface IBar2 extends IFoo2 {
+
+    /**
+     * {@inheritDoc}
+     */
+    public void doFoo();        // violation
+}
+
+class MoreJunk2 extends InputAntlr4AstRegressionBadOverride {
+
+    /**
+     * {@inheritDoc}
+     */
+    public void doFoo() {}      // violation
+
+    /**
+     * {@inheritDoc}
+     */
+    public void doFoo2() {}     // violation
+
+    class EvenMoreJunk extends MoreJunk2 implements Serializable {
+
+        /**
+         * {@inheritDoc}
+         */
+        public void doFoo() {}      // violation
+
+        /**
+         * {@inheritDoc}
+         */
+        public void doFoo2() {}     // violation
+    }
+}
+
+enum Football2 implements IFoo2, IBar2 {
+    Detroit_Lions;
+
+    /**
+     * {@inheritDoc}
+     */
+    public void doFoo() {}      // violation
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionBadOverride.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionBadOverride.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionBadOverride.txt
@@ -0,0 +1,176 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+IMPORT -> import [3:0]
+|--DOT -> . [3:14]
+|   |--DOT -> . [3:11]
+|   |   |--IDENT -> java [3:7]
+|   |   `--IDENT -> io [3:12]
+|   `--IDENT -> Serializable [3:15]
+`--SEMI -> ; [3:27]
+CLASS_DEF -> CLASS_DEF [5:0]
+|--MODIFIERS -> MODIFIERS [5:0]
+|   `--LITERAL_PUBLIC -> public [5:0]
+|--LITERAL_CLASS -> class [5:7]
+|--IDENT -> InputAntlr4AstRegressionBadOverride [5:13]
+`--OBJBLOCK -> OBJBLOCK [5:49]
+    |--LCURLY -> { [5:49]
+    |--METHOD_DEF -> METHOD_DEF [9:4]
+    |   |--MODIFIERS -> MODIFIERS [9:4]
+    |   |   `--LITERAL_PUBLIC -> public [9:4]
+    |   |--TYPE -> TYPE [9:11]
+    |   |   `--LITERAL_VOID -> void [9:11]
+    |   |--IDENT -> doFoo [9:16]
+    |   |--LPAREN -> ( [9:21]
+    |   |--PARAMETERS -> PARAMETERS [9:22]
+    |   |--RPAREN -> ) [9:22]
+    |   `--SLIST -> { [9:24]
+    |       `--RCURLY -> } [9:25]
+    |--METHOD_DEF -> METHOD_DEF [11:4]
+    |   |--MODIFIERS -> MODIFIERS [11:4]
+    |   |   `--LITERAL_PUBLIC -> public [11:4]
+    |   |--TYPE -> TYPE [11:11]
+    |   |   `--LITERAL_VOID -> void [11:11]
+    |   |--IDENT -> doFoo2 [11:16]
+    |   |--LPAREN -> ( [11:22]
+    |   |--PARAMETERS -> PARAMETERS [11:23]
+    |   |--RPAREN -> ) [11:23]
+    |   `--SLIST -> { [11:25]
+    |       `--RCURLY -> } [11:26]
+    `--RCURLY -> } [13:0]
+INTERFACE_DEF -> INTERFACE_DEF [15:0]
+|--MODIFIERS -> MODIFIERS [15:0]
+|--LITERAL_INTERFACE -> interface [15:0]
+|--IDENT -> IFoo2 [15:10]
+`--OBJBLOCK -> OBJBLOCK [15:16]
+    |--LCURLY -> { [15:16]
+    |--METHOD_DEF -> METHOD_DEF [17:4]
+    |   |--MODIFIERS -> MODIFIERS [17:4]
+    |   |--TYPE -> TYPE [17:4]
+    |   |   `--LITERAL_VOID -> void [17:4]
+    |   |--IDENT -> doFoo [17:9]
+    |   |--LPAREN -> ( [17:14]
+    |   |--PARAMETERS -> PARAMETERS [17:15]
+    |   |--RPAREN -> ) [17:15]
+    |   `--SEMI -> ; [17:16]
+    `--RCURLY -> } [18:0]
+INTERFACE_DEF -> INTERFACE_DEF [20:0]
+|--MODIFIERS -> MODIFIERS [20:0]
+|--LITERAL_INTERFACE -> interface [20:0]
+|--IDENT -> IBar2 [20:10]
+|--EXTENDS_CLAUSE -> extends [20:16]
+|   `--IDENT -> IFoo2 [20:24]
+`--OBJBLOCK -> OBJBLOCK [20:30]
+    |--LCURLY -> { [20:30]
+    |--METHOD_DEF -> METHOD_DEF [25:4]
+    |   |--MODIFIERS -> MODIFIERS [25:4]
+    |   |   `--LITERAL_PUBLIC -> public [25:4]
+    |   |--TYPE -> TYPE [25:11]
+    |   |   `--LITERAL_VOID -> void [25:11]
+    |   |--IDENT -> doFoo [25:16]
+    |   |--LPAREN -> ( [25:21]
+    |   |--PARAMETERS -> PARAMETERS [25:22]
+    |   |--RPAREN -> ) [25:22]
+    |   `--SEMI -> ; [25:23]
+    `--RCURLY -> } [26:0]
+CLASS_DEF -> CLASS_DEF [28:0]
+|--MODIFIERS -> MODIFIERS [28:0]
+|--LITERAL_CLASS -> class [28:0]
+|--IDENT -> MoreJunk2 [28:6]
+|--EXTENDS_CLAUSE -> extends [28:16]
+|   `--IDENT -> InputAntlr4AstRegressionBadOverride [28:24]
+`--OBJBLOCK -> OBJBLOCK [28:60]
+    |--LCURLY -> { [28:60]
+    |--METHOD_DEF -> METHOD_DEF [33:4]
+    |   |--MODIFIERS -> MODIFIERS [33:4]
+    |   |   `--LITERAL_PUBLIC -> public [33:4]
+    |   |--TYPE -> TYPE [33:11]
+    |   |   `--LITERAL_VOID -> void [33:11]
+    |   |--IDENT -> doFoo [33:16]
+    |   |--LPAREN -> ( [33:21]
+    |   |--PARAMETERS -> PARAMETERS [33:22]
+    |   |--RPAREN -> ) [33:22]
+    |   `--SLIST -> { [33:24]
+    |       `--RCURLY -> } [33:25]
+    |--METHOD_DEF -> METHOD_DEF [38:4]
+    |   |--MODIFIERS -> MODIFIERS [38:4]
+    |   |   `--LITERAL_PUBLIC -> public [38:4]
+    |   |--TYPE -> TYPE [38:11]
+    |   |   `--LITERAL_VOID -> void [38:11]
+    |   |--IDENT -> doFoo2 [38:16]
+    |   |--LPAREN -> ( [38:22]
+    |   |--PARAMETERS -> PARAMETERS [38:23]
+    |   |--RPAREN -> ) [38:23]
+    |   `--SLIST -> { [38:25]
+    |       `--RCURLY -> } [38:26]
+    |--CLASS_DEF -> CLASS_DEF [40:4]
+    |   |--MODIFIERS -> MODIFIERS [40:4]
+    |   |--LITERAL_CLASS -> class [40:4]
+    |   |--IDENT -> EvenMoreJunk [40:10]
+    |   |--EXTENDS_CLAUSE -> extends [40:23]
+    |   |   `--IDENT -> MoreJunk2 [40:31]
+    |   |--IMPLEMENTS_CLAUSE -> implements [40:41]
+    |   |   `--IDENT -> Serializable [40:52]
+    |   `--OBJBLOCK -> OBJBLOCK [40:65]
+    |       |--LCURLY -> { [40:65]
+    |       |--METHOD_DEF -> METHOD_DEF [45:8]
+    |       |   |--MODIFIERS -> MODIFIERS [45:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [45:8]
+    |       |   |--TYPE -> TYPE [45:15]
+    |       |   |   `--LITERAL_VOID -> void [45:15]
+    |       |   |--IDENT -> doFoo [45:20]
+    |       |   |--LPAREN -> ( [45:25]
+    |       |   |--PARAMETERS -> PARAMETERS [45:26]
+    |       |   |--RPAREN -> ) [45:26]
+    |       |   `--SLIST -> { [45:28]
+    |       |       `--RCURLY -> } [45:29]
+    |       |--METHOD_DEF -> METHOD_DEF [50:8]
+    |       |   |--MODIFIERS -> MODIFIERS [50:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [50:8]
+    |       |   |--TYPE -> TYPE [50:15]
+    |       |   |   `--LITERAL_VOID -> void [50:15]
+    |       |   |--IDENT -> doFoo2 [50:20]
+    |       |   |--LPAREN -> ( [50:26]
+    |       |   |--PARAMETERS -> PARAMETERS [50:27]
+    |       |   |--RPAREN -> ) [50:27]
+    |       |   `--SLIST -> { [50:29]
+    |       |       `--RCURLY -> } [50:30]
+    |       `--RCURLY -> } [51:4]
+    `--RCURLY -> } [52:0]
+ENUM_DEF -> ENUM_DEF [54:0]
+|--MODIFIERS -> MODIFIERS [54:0]
+|--ENUM -> enum [54:0]
+|--IDENT -> Football2 [54:5]
+|--IMPLEMENTS_CLAUSE -> implements [54:15]
+|   |--IDENT -> IFoo2 [54:26]
+|   |--COMMA -> , [54:31]
+|   `--IDENT -> IBar2 [54:33]
+`--OBJBLOCK -> OBJBLOCK [54:39]
+    |--LCURLY -> { [54:39]
+    |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [55:4]
+    |   |--ANNOTATIONS -> ANNOTATIONS [55:4]
+    |   `--IDENT -> Detroit_Lions [55:4]
+    |--SEMI -> ; [55:17]
+    |--METHOD_DEF -> METHOD_DEF [60:4]
+    |   |--MODIFIERS -> MODIFIERS [60:4]
+    |   |   `--LITERAL_PUBLIC -> public [60:4]
+    |   |--TYPE -> TYPE [60:11]
+    |   |   `--LITERAL_VOID -> void [60:11]
+    |   |--IDENT -> doFoo [60:16]
+    |   |--LPAREN -> ( [60:21]
+    |   |--PARAMETERS -> PARAMETERS [60:22]
+    |   |--RPAREN -> ) [60:22]
+    |   `--SLIST -> { [60:24]
+    |       `--RCURLY -> } [60:25]
+    `--RCURLY -> } [61:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionCassandraInputWithComments.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionCassandraInputWithComments.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionCassandraInputWithComments.java
@@ -0,0 +1,415 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You under the Apache License, Version 2.0
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Date;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Properties;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.util.DOMElementWriter;
+import org.apache.tools.ant.util.DateUtils;
+import org.apache.tools.ant.util.FileUtils;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Text;
+
+interface IgnoredTestListener{}
+interface JUnitResultFormatter{}
+interface XMLConstants{}
+/**
+ * Prints XML output of the test to a specified Writer.
+ *
+ * @see FormatterElement
+ */
+public class InputAntlr4AstRegressionCassandraInputWithComments
+        implements JUnitResultFormatter, XMLConstants, IgnoredTestListener {
+
+    private static final double ONE_SECOND = 1000.0;
+
+    /** constant for unnnamed testsuites/cases */
+    private static final String UNKNOWN = "unknown";
+    private static final String ATTR_ERRORS = "";
+    private static final String TESTSUITE = "";
+    private static final String SYSTEM_OUT = "";
+    private static final String SYSTEM_ERR = "";
+
+    private static DocumentBuilder getDocumentBuilder() {
+        try {
+            return DocumentBuilderFactory.newInstance().newDocumentBuilder();
+        } catch (final Exception exc) {
+            throw new ExceptionInInitializerError(exc);
+        }
+    }
+
+    private static final String tag = System.getProperty("cassandra.testtag", "");
+
+    /*
+     * Set the property for the test suite name so that log configuration can pick it up
+     * and log to a file specific to this test suite
+     */
+    static
+    {
+        String command = System.getProperty("sun.java.command");
+        String args[] = command.split(" ");
+        System.setProperty("suitename", args[1]);
+    }
+
+    /**
+     * The XML document.
+     */
+    private Document doc;
+
+    /**
+     * The wrapper for the whole testsuite.
+     */
+    private Element rootElement;
+
+    /**
+     * Element for the current test.
+     *
+     * The keying of this map is a bit of a hack: tests are keyed by caseName(className) since
+     * the Test we get for Test-start isn't the same as the Test we get during test-assumption-fail,
+     * so we can't easily match Test objects without manually iterating over all keys and checking
+     * individual fields.
+     */
+    private final Hashtable<String, Element> testElements = new Hashtable<String, Element>();
+
+    /**
+     * tests that failed.
+     */
+    private final Hashtable failedTests = new Hashtable();
+
+    /**
+     * Tests that were skipped.
+     */
+    private final Hashtable<String, Test> skippedTests = new Hashtable<String, Test>();
+    /**
+     * Tests that were ignored. See the note above about the key being a bit of a hack.
+     */
+    private final Hashtable<String, Test> ignoredTests = new Hashtable<String, Test>();
+    /**
+     * Timing helper.
+     */
+    private final Hashtable<String, Long> testStarts = new Hashtable<String, Long>();
+    /**
+     * Where to write the log to.
+     */
+    private OutputStream out;
+
+    /** No arg constructor. */
+    public InputAntlr4AstRegressionCassandraInputWithComments() {
+    }
+
+    /** {@inheritDoc}. */
+    public void setOutput(final OutputStream out) {
+        this.out = out;
+    }
+
+    /** {@inheritDoc}. */
+    public void setSystemOutput(final String out) {
+        formatOutput(SYSTEM_OUT, out);
+    }
+
+    /** {@inheritDoc}. */
+    public void setSystemError(final String out) {
+        formatOutput(SYSTEM_ERR, out);
+    }
+
+    /**
+     * The whole testsuite started.
+     * @param suite the testsuite.
+     */
+    public void startTestSuite(final JUnitTest suite) {
+        doc = getDocumentBuilder().newDocument();
+        rootElement = doc.createElement(TESTSUITE);
+        String n = suite.getName();
+        if (n != null && !tag.isEmpty())
+            n = n + "-" + tag;
+        rootElement.setAttribute(ATTR_NAME, n == null ? UNKNOWN : n);
+
+        //add the timestamp
+        final String timestamp = DateUtils.format(new Date(),
+                DateUtils.ISO8601_DATETIME_PATTERN);
+        rootElement.setAttribute(TIMESTAMP, timestamp);
+        //and the hostname.
+        rootElement.setAttribute(HOSTNAME, getHostname());
+
+        // Output properties
+        final Element propsElement = doc.createElement(PROPERTIES);
+        rootElement.appendChild(propsElement);
+        final Properties props = suite.getProperties();
+        if (props != null) {
+            final Enumeration e = props.propertyNames();
+            while (e.hasMoreElements()) {
+                final String name = (String) e.nextElement();
+                final Element propElement = doc.createElement(PROPERTY);
+                propElement.setAttribute(ATTR_NAME, name);
+                propElement.setAttribute(ATTR_VALUE, props.getProperty(name));
+                propsElement.appendChild(propElement);
+            }
+        }
+    }
+
+    private static final String PROPERTIES = "";
+    private static final String HOSTNAME = "";
+    private static final String TIMESTAMP = "";
+    private static final String ATTR_NAME = "";
+    private static final String PROPERTY = "";
+    private static final String ATTR_VALUE = "";
+
+    class JUnitTest {
+        public String getName() {
+            return null;
+        }
+
+        public Properties getProperties() {
+            return null;
+        }
+
+        public String failureCount() {
+            return null;
+        }
+
+        public String getRunTime() {
+            return null;
+        }
+    }
+
+    /**
+     * get the local hostname
+     * @return the name of the local host, or "localhost" if we cannot work it out
+     */
+    private String getHostname()  {
+        String hostname = "localhost";
+        try {
+            final InetAddress localHost = InetAddress.getLocalHost();
+            if (localHost != null) {
+                hostname = localHost.getHostName();
+            }
+        } catch (final UnknownHostException e) {
+            // fall back to default 'localhost'
+        }
+        return hostname;
+    }
+
+    private static final String ATTR_TESTS = "";
+    private static final String ATTR_FAILURES = "";
+    private static final String ATTR_SKIPPED = "";
+
+    /**
+     * The whole testsuite ended.
+     * @param suite the testsuite.
+     * @throws BuildException on error.
+     */
+    public void endTestSuite(final JUnitTest suite) throws BuildException {
+        rootElement.setAttribute(ATTR_SKIPPED, "" + suite.failureCount());
+        rootElement.setAttribute(
+                ATTR_TESTS, "" + (ONE_SECOND));
+        if (out != null) {
+            Writer wri = null;
+            try {
+                wri = new BufferedWriter(new OutputStreamWriter(out, "UTF8"));
+                wri.write("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
+                (new DOMElementWriter()).write(rootElement, wri, 0, "  ");
+            } catch (final IOException exc) {
+                throw new BuildException("Unable to write log file", exc);
+            } finally {
+                if (wri != null) {
+                    try {
+                        wri.flush();
+                    } catch (final IOException ex) {
+                        // ignore
+                    }
+                }
+                if (out != System.out && out != System.err) {
+                    FileUtils.close(wri);
+                }
+            }
+        }
+    }
+
+    /**
+     * Interface TestListener.
+     *
+     * <p>A new Test is started.
+     * @param t the test.
+     */
+    public void startTest(final Test t) {
+        testStarts.put(createDescription(t),
+                System.currentTimeMillis());
+    }
+
+    private static String createDescription(final Test test) throws BuildException {
+        return null;
+    }
+
+    /**
+     * Interface TestListener.
+     *
+     * <p>A Test is finished.
+     * @param test the test.
+     */
+    public void endTest(final Test test) {
+        final String testDescription = createDescription(test);
+
+        // Fix for bug #5637 - if a junit.extensions.TestSetup is
+        // used and throws an exception during setUp then startTest
+        // would never have been called
+        if (!testStarts.containsKey(testDescription)) {
+            startTest(test);
+        }
+        Element currentTest;
+        if (!failedTests.containsKey(test) && !skippedTests.containsKey(testDescription)
+                && !ignoredTests.containsKey(testDescription)) {
+            currentTest = doc.createElement("TESTCASE");
+            String n = "";
+            if (n != null && !tag.isEmpty())
+                n = n + "-" + tag;
+            currentTest.setAttribute(ATTR_NAME,
+                                     n == null ? UNKNOWN : n);
+            // a TestSuite can contain Tests from multiple classes,
+            // even tests with the same name - disambiguate them.
+            currentTest.setAttribute("ATTR_CLASSNAME",
+                    "");
+            rootElement.appendChild(currentTest);
+            testElements.put(createDescription(test), currentTest);
+        } else {
+            currentTest = testElements.get(testDescription);
+        }
+
+        final Long l = testStarts.get(createDescription(test));
+    }
+
+    /**
+     * Interface TestListener for JUnit &lt;= 3.4.
+     *
+     * <p>A Test failed.
+     * @param test the test.
+     * @param t the exception.
+     */
+    public void addFailure(final Test test, final Throwable t) {
+        formatError("FAILURE", test, t);
+    }
+
+    /**
+     * Interface TestListener for JUnit &gt; 3.4.
+     *
+     * <p>A Test failed.
+     * @param test the test.
+     * @param t the assertion.
+     */
+    public void addFailure(final Test test, final AssertionFailedError t) {
+        addFailure(test, (Throwable) t);
+    }
+
+    /**
+     * Interface TestListener.
+     *
+     * <p>An error occurred while running the test.
+     * @param test the test.
+     * @param t the error.
+     */
+    public void addError(final Test test, final Throwable t) {
+        formatError("ERROR", test, t);
+    }
+
+    private void formatError(final String type, final Test test, final Throwable t) {
+        if (test != null) {
+            endTest(test);
+            failedTests.put(test, test);
+        }
+
+        final Element nested = doc.createElement(type);
+        Element currentTest;
+        if (test != null) {
+            currentTest = testElements.get(createDescription(test));
+        } else {
+            currentTest = rootElement;
+        }
+
+        currentTest.appendChild(nested);
+
+        final String message = t.getMessage();
+        if (message != null && message.length() > 0) {
+            nested.setAttribute("ATTR_MESSAGE", t.getMessage());
+        }
+        nested.setAttribute("ATTR_TYPE", t.getClass().getName());
+
+        final String strace = "JUnitTestRunner.getFilteredTrace(t";
+        final Text trace = doc.createTextNode(strace);
+        nested.appendChild(trace);
+    }
+
+    private void formatOutput(final String type, final String output) {
+        final Element nested = doc.createElement(type);
+        rootElement.appendChild(nested);
+        nested.appendChild(doc.createCDATASection(output));
+    }
+
+    public void testIgnored(final Test test) {
+        formatSkip(test, "JUnitVersionHelper.getIgnoreMessage(test)");
+        if (test != null) {
+            ignoredTests.put(createDescription(test), test);
+        }
+    }
+
+
+    public void formatSkip(final Test test, final String message) {
+        if (test != null) {
+            endTest(test);
+        }
+
+        final Element nested = doc.createElement("skipped");
+
+        if (message != null) {
+            nested.setAttribute("message", message);
+        }
+
+        Element currentTest;
+        if (test != null) {
+            currentTest = testElements.get(createDescription(test));
+        } else {
+            currentTest = rootElement;
+        }
+
+        currentTest.appendChild(nested);
+
+    }
+
+    public void testAssumptionFailure(final Test test, final Throwable failure) {
+        formatSkip(test, failure.getMessage());
+        skippedTests.put(createDescription(test), test);
+
+    }
+} // XMLJUnitResultFormatter, no newline on purpose
\ No newline at end of file
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionCassandraInputWithComments.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionCassandraInputWithComments.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionCassandraInputWithComments.txt
@@ -0,0 +1,2518 @@
+BLOCK_COMMENT_BEGIN -> /* [1:0]
+|--COMMENT_CONTENT -> \n *  Licensed to the Apache Software Foundation (ASF) under one or more\n *  contributor license agreements.  See the NOTICE file distributed with\n *  this work for additional information regarding copyright ownership.\n *  The ASF licenses this file to You under the Apache License, Version 2.0\n *  (the "License"); you may not use this file except in compliance with\n *  the License.  You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  Unless required by applicable law or agreed to in writing, software\n *  distributed under the License is distributed on an "AS IS" BASIS,\n *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *  See the License for the specific language governing permissions and\n *  limitations under the License.\n *\n  [1:2]
+`--BLOCK_COMMENT_END -> */ [17:1]
+PACKAGE_DEF -> package [19:0]
+|--ANNOTATIONS -> ANNOTATIONS [19:47]
+|--DOT -> . [19:47]
+|   |--DOT -> . [19:39]
+|   |   |--DOT -> . [19:28]
+|   |   |   |--DOT -> . [19:22]
+|   |   |   |   |--DOT -> . [19:11]
+|   |   |   |   |   |--IDENT -> com [19:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [19:12]
+|   |   |   |   `--IDENT -> tools [19:23]
+|   |   |   `--IDENT -> checkstyle [19:29]
+|   |   `--IDENT -> grammar [19:40]
+|   `--IDENT -> antlr4 [19:48]
+`--SEMI -> ; [19:54]
+IMPORT -> import [21:0]
+|--DOT -> . [21:14]
+|   |--DOT -> . [21:11]
+|   |   |--IDENT -> java [21:7]
+|   |   `--IDENT -> io [21:12]
+|   `--IDENT -> BufferedWriter [21:15]
+`--SEMI -> ; [21:29]
+IMPORT -> import [22:0]
+|--DOT -> . [22:14]
+|   |--DOT -> . [22:11]
+|   |   |--IDENT -> java [22:7]
+|   |   `--IDENT -> io [22:12]
+|   `--IDENT -> IOException [22:15]
+`--SEMI -> ; [22:26]
+IMPORT -> import [23:0]
+|--DOT -> . [23:14]
+|   |--DOT -> . [23:11]
+|   |   |--IDENT -> java [23:7]
+|   |   `--IDENT -> io [23:12]
+|   `--IDENT -> OutputStream [23:15]
+`--SEMI -> ; [23:27]
+IMPORT -> import [24:0]
+|--DOT -> . [24:14]
+|   |--DOT -> . [24:11]
+|   |   |--IDENT -> java [24:7]
+|   |   `--IDENT -> io [24:12]
+|   `--IDENT -> OutputStreamWriter [24:15]
+`--SEMI -> ; [24:33]
+IMPORT -> import [25:0]
+|--DOT -> . [25:14]
+|   |--DOT -> . [25:11]
+|   |   |--IDENT -> java [25:7]
+|   |   `--IDENT -> io [25:12]
+|   `--IDENT -> Writer [25:15]
+`--SEMI -> ; [25:21]
+IMPORT -> import [26:0]
+|--DOT -> . [26:15]
+|   |--DOT -> . [26:11]
+|   |   |--IDENT -> java [26:7]
+|   |   `--IDENT -> net [26:12]
+|   `--IDENT -> InetAddress [26:16]
+`--SEMI -> ; [26:27]
+IMPORT -> import [27:0]
+|--DOT -> . [27:15]
+|   |--DOT -> . [27:11]
+|   |   |--IDENT -> java [27:7]
+|   |   `--IDENT -> net [27:12]
+|   `--IDENT -> UnknownHostException [27:16]
+`--SEMI -> ; [27:36]
+IMPORT -> import [28:0]
+|--DOT -> . [28:16]
+|   |--DOT -> . [28:11]
+|   |   |--IDENT -> java [28:7]
+|   |   `--IDENT -> util [28:12]
+|   `--IDENT -> Date [28:17]
+`--SEMI -> ; [28:21]
+IMPORT -> import [29:0]
+|--DOT -> . [29:16]
+|   |--DOT -> . [29:11]
+|   |   |--IDENT -> java [29:7]
+|   |   `--IDENT -> util [29:12]
+|   `--IDENT -> Enumeration [29:17]
+`--SEMI -> ; [29:28]
+IMPORT -> import [30:0]
+|--DOT -> . [30:16]
+|   |--DOT -> . [30:11]
+|   |   |--IDENT -> java [30:7]
+|   |   `--IDENT -> util [30:12]
+|   `--IDENT -> Hashtable [30:17]
+`--SEMI -> ; [30:26]
+IMPORT -> import [31:0]
+|--DOT -> . [31:16]
+|   |--DOT -> . [31:11]
+|   |   |--IDENT -> java [31:7]
+|   |   `--IDENT -> util [31:12]
+|   `--IDENT -> Properties [31:17]
+`--SEMI -> ; [31:27]
+IMPORT -> import [33:0]
+|--DOT -> . [33:24]
+|   |--DOT -> . [33:16]
+|   |   |--DOT -> . [33:12]
+|   |   |   |--IDENT -> javax [33:7]
+|   |   |   `--IDENT -> xml [33:13]
+|   |   `--IDENT -> parsers [33:17]
+|   `--IDENT -> DocumentBuilder [33:25]
+`--SEMI -> ; [33:40]
+IMPORT -> import [34:0]
+|--DOT -> . [34:24]
+|   |--DOT -> . [34:16]
+|   |   |--DOT -> . [34:12]
+|   |   |   |--IDENT -> javax [34:7]
+|   |   |   `--IDENT -> xml [34:13]
+|   |   `--IDENT -> parsers [34:17]
+|   `--IDENT -> DocumentBuilderFactory [34:25]
+`--SEMI -> ; [34:47]
+IMPORT -> import [36:0]
+|--DOT -> . [36:22]
+|   |--DOT -> . [36:12]
+|   |   |--IDENT -> junit [36:7]
+|   |   `--IDENT -> framework [36:13]
+|   `--IDENT -> AssertionFailedError [36:23]
+`--SEMI -> ; [36:43]
+IMPORT -> import [37:0]
+|--DOT -> . [37:22]
+|   |--DOT -> . [37:12]
+|   |   |--IDENT -> junit [37:7]
+|   |   `--IDENT -> framework [37:13]
+|   `--IDENT -> Test [37:23]
+`--SEMI -> ; [37:27]
+IMPORT -> import [39:0]
+|--DOT -> . [39:27]
+|   |--DOT -> . [39:23]
+|   |   |--DOT -> . [39:17]
+|   |   |   |--DOT -> . [39:10]
+|   |   |   |   |--IDENT -> org [39:7]
+|   |   |   |   `--IDENT -> apache [39:11]
+|   |   |   `--IDENT -> tools [39:18]
+|   |   `--IDENT -> ant [39:24]
+|   `--IDENT -> BuildException [39:28]
+`--SEMI -> ; [39:42]
+IMPORT -> import [40:0]
+|--DOT -> . [40:32]
+|   |--DOT -> . [40:27]
+|   |   |--DOT -> . [40:23]
+|   |   |   |--DOT -> . [40:17]
+|   |   |   |   |--DOT -> . [40:10]
+|   |   |   |   |   |--IDENT -> org [40:7]
+|   |   |   |   |   `--IDENT -> apache [40:11]
+|   |   |   |   `--IDENT -> tools [40:18]
+|   |   |   `--IDENT -> ant [40:24]
+|   |   `--IDENT -> util [40:28]
+|   `--IDENT -> DOMElementWriter [40:33]
+`--SEMI -> ; [40:49]
+IMPORT -> import [41:0]
+|--DOT -> . [41:32]
+|   |--DOT -> . [41:27]
+|   |   |--DOT -> . [41:23]
+|   |   |   |--DOT -> . [41:17]
+|   |   |   |   |--DOT -> . [41:10]
+|   |   |   |   |   |--IDENT -> org [41:7]
+|   |   |   |   |   `--IDENT -> apache [41:11]
+|   |   |   |   `--IDENT -> tools [41:18]
+|   |   |   `--IDENT -> ant [41:24]
+|   |   `--IDENT -> util [41:28]
+|   `--IDENT -> DateUtils [41:33]
+`--SEMI -> ; [41:42]
+IMPORT -> import [42:0]
+|--DOT -> . [42:32]
+|   |--DOT -> . [42:27]
+|   |   |--DOT -> . [42:23]
+|   |   |   |--DOT -> . [42:17]
+|   |   |   |   |--DOT -> . [42:10]
+|   |   |   |   |   |--IDENT -> org [42:7]
+|   |   |   |   |   `--IDENT -> apache [42:11]
+|   |   |   |   `--IDENT -> tools [42:18]
+|   |   |   `--IDENT -> ant [42:24]
+|   |   `--IDENT -> util [42:28]
+|   `--IDENT -> FileUtils [42:33]
+`--SEMI -> ; [42:42]
+IMPORT -> import [43:0]
+|--DOT -> . [43:18]
+|   |--DOT -> . [43:14]
+|   |   |--DOT -> . [43:10]
+|   |   |   |--IDENT -> org [43:7]
+|   |   |   `--IDENT -> w3c [43:11]
+|   |   `--IDENT -> dom [43:15]
+|   `--IDENT -> Document [43:19]
+`--SEMI -> ; [43:27]
+IMPORT -> import [44:0]
+|--DOT -> . [44:18]
+|   |--DOT -> . [44:14]
+|   |   |--DOT -> . [44:10]
+|   |   |   |--IDENT -> org [44:7]
+|   |   |   `--IDENT -> w3c [44:11]
+|   |   `--IDENT -> dom [44:15]
+|   `--IDENT -> Element [44:19]
+`--SEMI -> ; [44:26]
+IMPORT -> import [45:0]
+|--DOT -> . [45:18]
+|   |--DOT -> . [45:14]
+|   |   |--DOT -> . [45:10]
+|   |   |   |--IDENT -> org [45:7]
+|   |   |   `--IDENT -> w3c [45:11]
+|   |   `--IDENT -> dom [45:15]
+|   `--IDENT -> Text [45:19]
+`--SEMI -> ; [45:23]
+INTERFACE_DEF -> INTERFACE_DEF [47:0]
+|--MODIFIERS -> MODIFIERS [47:0]
+|--LITERAL_INTERFACE -> interface [47:0]
+|--IDENT -> IgnoredTestListener [47:10]
+`--OBJBLOCK -> OBJBLOCK [47:29]
+    |--LCURLY -> { [47:29]
+    `--RCURLY -> } [47:30]
+INTERFACE_DEF -> INTERFACE_DEF [48:0]
+|--MODIFIERS -> MODIFIERS [48:0]
+|--LITERAL_INTERFACE -> interface [48:0]
+|--IDENT -> JUnitResultFormatter [48:10]
+`--OBJBLOCK -> OBJBLOCK [48:30]
+    |--LCURLY -> { [48:30]
+    `--RCURLY -> } [48:31]
+INTERFACE_DEF -> INTERFACE_DEF [49:0]
+|--MODIFIERS -> MODIFIERS [49:0]
+|--LITERAL_INTERFACE -> interface [49:0]
+|--IDENT -> XMLConstants [49:10]
+`--OBJBLOCK -> OBJBLOCK [49:22]
+    |--LCURLY -> { [49:22]
+    `--RCURLY -> } [49:23]
+CLASS_DEF -> CLASS_DEF [55:0]
+|--MODIFIERS -> MODIFIERS [55:0]
+|   |--BLOCK_COMMENT_BEGIN -> /* [50:0]
+|   |   |--COMMENT_CONTENT -> *\n * Prints XML output of the test to a specified Writer.\n *\n * @see FormatterElement\n  [50:2]
+|   |   `--BLOCK_COMMENT_END -> */ [54:1]
+|   `--LITERAL_PUBLIC -> public [55:0]
+|--LITERAL_CLASS -> class [55:7]
+|--IDENT -> InputAntlr4AstRegressionCassandraInputWithComments [55:13]
+|--IMPLEMENTS_CLAUSE -> implements [56:8]
+|   |--IDENT -> JUnitResultFormatter [56:19]
+|   |--COMMA -> , [56:39]
+|   |--IDENT -> XMLConstants [56:41]
+|   |--COMMA -> , [56:53]
+|   `--IDENT -> IgnoredTestListener [56:55]
+`--OBJBLOCK -> OBJBLOCK [56:75]
+    |--LCURLY -> { [56:75]
+    |--VARIABLE_DEF -> VARIABLE_DEF [58:4]
+    |   |--MODIFIERS -> MODIFIERS [58:4]
+    |   |   |--LITERAL_PRIVATE -> private [58:4]
+    |   |   |--LITERAL_STATIC -> static [58:12]
+    |   |   `--FINAL -> final [58:19]
+    |   |--TYPE -> TYPE [58:25]
+    |   |   `--LITERAL_DOUBLE -> double [58:25]
+    |   |--IDENT -> ONE_SECOND [58:32]
+    |   |--ASSIGN -> = [58:43]
+    |   |   `--EXPR -> EXPR [58:45]
+    |   |       `--NUM_FLOAT -> 1000.0 [58:45]
+    |   `--SEMI -> ; [58:51]
+    |--VARIABLE_DEF -> VARIABLE_DEF [61:4]
+    |   |--MODIFIERS -> MODIFIERS [61:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [60:4]
+    |   |   |   |--COMMENT_CONTENT -> * constant for unnnamed testsuites/cases  [60:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [60:46]
+    |   |   |--LITERAL_PRIVATE -> private [61:4]
+    |   |   |--LITERAL_STATIC -> static [61:12]
+    |   |   `--FINAL -> final [61:19]
+    |   |--TYPE -> TYPE [61:25]
+    |   |   `--IDENT -> String [61:25]
+    |   |--IDENT -> UNKNOWN [61:32]
+    |   |--ASSIGN -> = [61:40]
+    |   |   `--EXPR -> EXPR [61:42]
+    |   |       `--STRING_LITERAL -> "unknown" [61:42]
+    |   `--SEMI -> ; [61:51]
+    |--VARIABLE_DEF -> VARIABLE_DEF [62:4]
+    |   |--MODIFIERS -> MODIFIERS [62:4]
+    |   |   |--LITERAL_PRIVATE -> private [62:4]
+    |   |   |--LITERAL_STATIC -> static [62:12]
+    |   |   `--FINAL -> final [62:19]
+    |   |--TYPE -> TYPE [62:25]
+    |   |   `--IDENT -> String [62:25]
+    |   |--IDENT -> ATTR_ERRORS [62:32]
+    |   |--ASSIGN -> = [62:44]
+    |   |   `--EXPR -> EXPR [62:46]
+    |   |       `--STRING_LITERAL -> "" [62:46]
+    |   `--SEMI -> ; [62:48]
+    |--VARIABLE_DEF -> VARIABLE_DEF [63:4]
+    |   |--MODIFIERS -> MODIFIERS [63:4]
+    |   |   |--LITERAL_PRIVATE -> private [63:4]
+    |   |   |--LITERAL_STATIC -> static [63:12]
+    |   |   `--FINAL -> final [63:19]
+    |   |--TYPE -> TYPE [63:25]
+    |   |   `--IDENT -> String [63:25]
+    |   |--IDENT -> TESTSUITE [63:32]
+    |   |--ASSIGN -> = [63:42]
+    |   |   `--EXPR -> EXPR [63:44]
+    |   |       `--STRING_LITERAL -> "" [63:44]
+    |   `--SEMI -> ; [63:46]
+    |--VARIABLE_DEF -> VARIABLE_DEF [64:4]
+    |   |--MODIFIERS -> MODIFIERS [64:4]
+    |   |   |--LITERAL_PRIVATE -> private [64:4]
+    |   |   |--LITERAL_STATIC -> static [64:12]
+    |   |   `--FINAL -> final [64:19]
+    |   |--TYPE -> TYPE [64:25]
+    |   |   `--IDENT -> String [64:25]
+    |   |--IDENT -> SYSTEM_OUT [64:32]
+    |   |--ASSIGN -> = [64:43]
+    |   |   `--EXPR -> EXPR [64:45]
+    |   |       `--STRING_LITERAL -> "" [64:45]
+    |   `--SEMI -> ; [64:47]
+    |--VARIABLE_DEF -> VARIABLE_DEF [65:4]
+    |   |--MODIFIERS -> MODIFIERS [65:4]
+    |   |   |--LITERAL_PRIVATE -> private [65:4]
+    |   |   |--LITERAL_STATIC -> static [65:12]
+    |   |   `--FINAL -> final [65:19]
+    |   |--TYPE -> TYPE [65:25]
+    |   |   `--IDENT -> String [65:25]
+    |   |--IDENT -> SYSTEM_ERR [65:32]
+    |   |--ASSIGN -> = [65:43]
+    |   |   `--EXPR -> EXPR [65:45]
+    |   |       `--STRING_LITERAL -> "" [65:45]
+    |   `--SEMI -> ; [65:47]
+    |--METHOD_DEF -> METHOD_DEF [67:4]
+    |   |--MODIFIERS -> MODIFIERS [67:4]
+    |   |   |--LITERAL_PRIVATE -> private [67:4]
+    |   |   `--LITERAL_STATIC -> static [67:12]
+    |   |--TYPE -> TYPE [67:19]
+    |   |   `--IDENT -> DocumentBuilder [67:19]
+    |   |--IDENT -> getDocumentBuilder [67:35]
+    |   |--LPAREN -> ( [67:53]
+    |   |--PARAMETERS -> PARAMETERS [67:54]
+    |   |--RPAREN -> ) [67:54]
+    |   `--SLIST -> { [67:56]
+    |       |--LITERAL_TRY -> try [68:8]
+    |       |   |--SLIST -> { [68:12]
+    |       |   |   |--LITERAL_RETURN -> return [69:12]
+    |       |   |   |   |--EXPR -> EXPR [69:74]
+    |       |   |   |   |   `--METHOD_CALL -> ( [69:74]
+    |       |   |   |   |       |--DOT -> . [69:55]
+    |       |   |   |   |       |   |--METHOD_CALL -> ( [69:53]
+    |       |   |   |   |       |   |   |--DOT -> . [69:41]
+    |       |   |   |   |       |   |   |   |--IDENT -> DocumentBuilderFactory [69:19]
+    |       |   |   |   |       |   |   |   `--IDENT -> newInstance [69:42]
+    |       |   |   |   |       |   |   |--ELIST -> ELIST [69:54]
+    |       |   |   |   |       |   |   `--RPAREN -> ) [69:54]
+    |       |   |   |   |       |   `--IDENT -> newDocumentBuilder [69:56]
+    |       |   |   |   |       |--ELIST -> ELIST [69:75]
+    |       |   |   |   |       `--RPAREN -> ) [69:75]
+    |       |   |   |   `--SEMI -> ; [69:76]
+    |       |   |   `--RCURLY -> } [70:8]
+    |       |   `--LITERAL_CATCH -> catch [70:10]
+    |       |       |--LPAREN -> ( [70:16]
+    |       |       |--PARAMETER_DEF -> PARAMETER_DEF [70:17]
+    |       |       |   |--MODIFIERS -> MODIFIERS [70:17]
+    |       |       |   |   `--FINAL -> final [70:17]
+    |       |       |   |--TYPE -> TYPE [70:23]
+    |       |       |   |   `--IDENT -> Exception [70:23]
+    |       |       |   `--IDENT -> exc [70:33]
+    |       |       |--RPAREN -> ) [70:36]
+    |       |       `--SLIST -> { [70:38]
+    |       |           |--LITERAL_THROW -> throw [71:12]
+    |       |           |   |--EXPR -> EXPR [71:18]
+    |       |           |   |   `--LITERAL_NEW -> new [71:18]
+    |       |           |   |       |--IDENT -> ExceptionInInitializerError [71:22]
+    |       |           |   |       |--LPAREN -> ( [71:49]
+    |       |           |   |       |--ELIST -> ELIST [71:50]
+    |       |           |   |       |   `--EXPR -> EXPR [71:50]
+    |       |           |   |       |       `--IDENT -> exc [71:50]
+    |       |           |   |       `--RPAREN -> ) [71:53]
+    |       |           |   `--SEMI -> ; [71:54]
+    |       |           `--RCURLY -> } [72:8]
+    |       `--RCURLY -> } [73:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [75:4]
+    |   |--MODIFIERS -> MODIFIERS [75:4]
+    |   |   |--LITERAL_PRIVATE -> private [75:4]
+    |   |   |--LITERAL_STATIC -> static [75:12]
+    |   |   `--FINAL -> final [75:19]
+    |   |--TYPE -> TYPE [75:25]
+    |   |   `--IDENT -> String [75:25]
+    |   |--IDENT -> tag [75:32]
+    |   |--ASSIGN -> = [75:36]
+    |   |   `--EXPR -> EXPR [75:56]
+    |   |       `--METHOD_CALL -> ( [75:56]
+    |   |           |--DOT -> . [75:44]
+    |   |           |   |--IDENT -> System [75:38]
+    |   |           |   `--IDENT -> getProperty [75:45]
+    |   |           |--ELIST -> ELIST [75:57]
+    |   |           |   |--EXPR -> EXPR [75:57]
+    |   |           |   |   `--STRING_LITERAL -> "cassandra.testtag" [75:57]
+    |   |           |   |--COMMA -> , [75:76]
+    |   |           |   `--EXPR -> EXPR [75:78]
+    |   |           |       `--STRING_LITERAL -> "" [75:78]
+    |   |           `--RPAREN -> ) [75:80]
+    |   `--SEMI -> ; [75:81]
+    |--BLOCK_COMMENT_BEGIN -> /* [77:4]
+    |   |--COMMENT_CONTENT -> \n     * Set the property for the test suite name so that log configuration can pick it up\n     * and log to a file specific to this test suite\n      [77:6]
+    |   `--BLOCK_COMMENT_END -> */ [80:5]
+    |--STATIC_INIT -> STATIC_INIT [81:4]
+    |   `--SLIST -> { [82:4]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [83:8]
+    |       |   |--MODIFIERS -> MODIFIERS [83:8]
+    |       |   |--TYPE -> TYPE [83:8]
+    |       |   |   `--IDENT -> String [83:8]
+    |       |   |--IDENT -> command [83:15]
+    |       |   `--ASSIGN -> = [83:23]
+    |       |       `--EXPR -> EXPR [83:43]
+    |       |           `--METHOD_CALL -> ( [83:43]
+    |       |               |--DOT -> . [83:31]
+    |       |               |   |--IDENT -> System [83:25]
+    |       |               |   `--IDENT -> getProperty [83:32]
+    |       |               |--ELIST -> ELIST [83:44]
+    |       |               |   `--EXPR -> EXPR [83:44]
+    |       |               |       `--STRING_LITERAL -> "sun.java.command" [83:44]
+    |       |               `--RPAREN -> ) [83:62]
+    |       |--SEMI -> ; [83:63]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [84:8]
+    |       |   |--MODIFIERS -> MODIFIERS [84:8]
+    |       |   |--TYPE -> TYPE [84:8]
+    |       |   |   |--IDENT -> String [84:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [84:19]
+    |       |   |       `--RBRACK -> ] [84:20]
+    |       |   |--IDENT -> args [84:15]
+    |       |   `--ASSIGN -> = [84:22]
+    |       |       `--EXPR -> EXPR [84:37]
+    |       |           `--METHOD_CALL -> ( [84:37]
+    |       |               |--DOT -> . [84:31]
+    |       |               |   |--IDENT -> command [84:24]
+    |       |               |   `--IDENT -> split [84:32]
+    |       |               |--ELIST -> ELIST [84:38]
+    |       |               |   `--EXPR -> EXPR [84:38]
+    |       |               |       `--STRING_LITERAL -> " " [84:38]
+    |       |               `--RPAREN -> ) [84:41]
+    |       |--SEMI -> ; [84:42]
+    |       |--EXPR -> EXPR [85:26]
+    |       |   `--METHOD_CALL -> ( [85:26]
+    |       |       |--DOT -> . [85:14]
+    |       |       |   |--IDENT -> System [85:8]
+    |       |       |   `--IDENT -> setProperty [85:15]
+    |       |       |--ELIST -> ELIST [85:27]
+    |       |       |   |--EXPR -> EXPR [85:27]
+    |       |       |   |   `--STRING_LITERAL -> "suitename" [85:27]
+    |       |       |   |--COMMA -> , [85:38]
+    |       |       |   `--EXPR -> EXPR [85:44]
+    |       |       |       `--INDEX_OP -> [ [85:44]
+    |       |       |           |--IDENT -> args [85:40]
+    |       |       |           |--EXPR -> EXPR [85:45]
+    |       |       |           |   `--NUM_INT -> 1 [85:45]
+    |       |       |           `--RBRACK -> ] [85:46]
+    |       |       `--RPAREN -> ) [85:47]
+    |       |--SEMI -> ; [85:48]
+    |       `--RCURLY -> } [86:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [91:4]
+    |   |--MODIFIERS -> MODIFIERS [91:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [88:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * The XML document.\n      [88:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [90:5]
+    |   |   `--LITERAL_PRIVATE -> private [91:4]
+    |   |--TYPE -> TYPE [91:12]
+    |   |   `--IDENT -> Document [91:12]
+    |   |--IDENT -> doc [91:21]
+    |   `--SEMI -> ; [91:24]
+    |--VARIABLE_DEF -> VARIABLE_DEF [96:4]
+    |   |--MODIFIERS -> MODIFIERS [96:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [93:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * The wrapper for the whole testsuite.\n      [93:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [95:5]
+    |   |   `--LITERAL_PRIVATE -> private [96:4]
+    |   |--TYPE -> TYPE [96:12]
+    |   |   `--IDENT -> Element [96:12]
+    |   |--IDENT -> rootElement [96:20]
+    |   `--SEMI -> ; [96:31]
+    |--VARIABLE_DEF -> VARIABLE_DEF [106:4]
+    |   |--MODIFIERS -> MODIFIERS [106:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [98:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * Element for the current test.\n     *\n     * The keying of this map is a bit of a hack: tests are keyed by caseName(className) since\n     * the Test we get for Test-start isn't the same as the Test we get during test-assumption-fail,\n     * so we can't easily match Test objects without manually iterating over all keys and checking\n     * individual fields.\n      [98:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [105:5]
+    |   |   |--LITERAL_PRIVATE -> private [106:4]
+    |   |   `--FINAL -> final [106:12]
+    |   |--TYPE -> TYPE [106:18]
+    |   |   |--IDENT -> Hashtable [106:18]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [106:27]
+    |   |       |--GENERIC_START -> < [106:27]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [106:28]
+    |   |       |   `--IDENT -> String [106:28]
+    |   |       |--COMMA -> , [106:34]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [106:36]
+    |   |       |   `--IDENT -> Element [106:36]
+    |   |       `--GENERIC_END -> > [106:43]
+    |   |--IDENT -> testElements [106:45]
+    |   |--ASSIGN -> = [106:58]
+    |   |   `--EXPR -> EXPR [106:60]
+    |   |       `--LITERAL_NEW -> new [106:60]
+    |   |           |--IDENT -> Hashtable [106:64]
+    |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [106:73]
+    |   |           |   |--GENERIC_START -> < [106:73]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [106:74]
+    |   |           |   |   `--IDENT -> String [106:74]
+    |   |           |   |--COMMA -> , [106:80]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [106:82]
+    |   |           |   |   `--IDENT -> Element [106:82]
+    |   |           |   `--GENERIC_END -> > [106:89]
+    |   |           |--LPAREN -> ( [106:90]
+    |   |           |--ELIST -> ELIST [106:91]
+    |   |           `--RPAREN -> ) [106:91]
+    |   `--SEMI -> ; [106:92]
+    |--VARIABLE_DEF -> VARIABLE_DEF [111:4]
+    |   |--MODIFIERS -> MODIFIERS [111:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [108:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * tests that failed.\n      [108:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [110:5]
+    |   |   |--LITERAL_PRIVATE -> private [111:4]
+    |   |   `--FINAL -> final [111:12]
+    |   |--TYPE -> TYPE [111:18]
+    |   |   `--IDENT -> Hashtable [111:18]
+    |   |--IDENT -> failedTests [111:28]
+    |   |--ASSIGN -> = [111:40]
+    |   |   `--EXPR -> EXPR [111:42]
+    |   |       `--LITERAL_NEW -> new [111:42]
+    |   |           |--IDENT -> Hashtable [111:46]
+    |   |           |--LPAREN -> ( [111:55]
+    |   |           |--ELIST -> ELIST [111:56]
+    |   |           `--RPAREN -> ) [111:56]
+    |   `--SEMI -> ; [111:57]
+    |--VARIABLE_DEF -> VARIABLE_DEF [116:4]
+    |   |--MODIFIERS -> MODIFIERS [116:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [113:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * Tests that were skipped.\n      [113:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [115:5]
+    |   |   |--LITERAL_PRIVATE -> private [116:4]
+    |   |   `--FINAL -> final [116:12]
+    |   |--TYPE -> TYPE [116:18]
+    |   |   |--IDENT -> Hashtable [116:18]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [116:27]
+    |   |       |--GENERIC_START -> < [116:27]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [116:28]
+    |   |       |   `--IDENT -> String [116:28]
+    |   |       |--COMMA -> , [116:34]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [116:36]
+    |   |       |   `--IDENT -> Test [116:36]
+    |   |       `--GENERIC_END -> > [116:40]
+    |   |--IDENT -> skippedTests [116:42]
+    |   |--ASSIGN -> = [116:55]
+    |   |   `--EXPR -> EXPR [116:57]
+    |   |       `--LITERAL_NEW -> new [116:57]
+    |   |           |--IDENT -> Hashtable [116:61]
+    |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [116:70]
+    |   |           |   |--GENERIC_START -> < [116:70]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [116:71]
+    |   |           |   |   `--IDENT -> String [116:71]
+    |   |           |   |--COMMA -> , [116:77]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [116:79]
+    |   |           |   |   `--IDENT -> Test [116:79]
+    |   |           |   `--GENERIC_END -> > [116:83]
+    |   |           |--LPAREN -> ( [116:84]
+    |   |           |--ELIST -> ELIST [116:85]
+    |   |           `--RPAREN -> ) [116:85]
+    |   `--SEMI -> ; [116:86]
+    |--VARIABLE_DEF -> VARIABLE_DEF [120:4]
+    |   |--MODIFIERS -> MODIFIERS [120:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [117:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * Tests that were ignored. See the note above about the key being a bit of a hack.\n      [117:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [119:5]
+    |   |   |--LITERAL_PRIVATE -> private [120:4]
+    |   |   `--FINAL -> final [120:12]
+    |   |--TYPE -> TYPE [120:18]
+    |   |   |--IDENT -> Hashtable [120:18]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [120:27]
+    |   |       |--GENERIC_START -> < [120:27]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [120:28]
+    |   |       |   `--IDENT -> String [120:28]
+    |   |       |--COMMA -> , [120:34]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [120:36]
+    |   |       |   `--IDENT -> Test [120:36]
+    |   |       `--GENERIC_END -> > [120:40]
+    |   |--IDENT -> ignoredTests [120:42]
+    |   |--ASSIGN -> = [120:55]
+    |   |   `--EXPR -> EXPR [120:57]
+    |   |       `--LITERAL_NEW -> new [120:57]
+    |   |           |--IDENT -> Hashtable [120:61]
+    |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [120:70]
+    |   |           |   |--GENERIC_START -> < [120:70]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [120:71]
+    |   |           |   |   `--IDENT -> String [120:71]
+    |   |           |   |--COMMA -> , [120:77]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [120:79]
+    |   |           |   |   `--IDENT -> Test [120:79]
+    |   |           |   `--GENERIC_END -> > [120:83]
+    |   |           |--LPAREN -> ( [120:84]
+    |   |           |--ELIST -> ELIST [120:85]
+    |   |           `--RPAREN -> ) [120:85]
+    |   `--SEMI -> ; [120:86]
+    |--VARIABLE_DEF -> VARIABLE_DEF [124:4]
+    |   |--MODIFIERS -> MODIFIERS [124:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [121:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * Timing helper.\n      [121:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [123:5]
+    |   |   |--LITERAL_PRIVATE -> private [124:4]
+    |   |   `--FINAL -> final [124:12]
+    |   |--TYPE -> TYPE [124:18]
+    |   |   |--IDENT -> Hashtable [124:18]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [124:27]
+    |   |       |--GENERIC_START -> < [124:27]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [124:28]
+    |   |       |   `--IDENT -> String [124:28]
+    |   |       |--COMMA -> , [124:34]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [124:36]
+    |   |       |   `--IDENT -> Long [124:36]
+    |   |       `--GENERIC_END -> > [124:40]
+    |   |--IDENT -> testStarts [124:42]
+    |   |--ASSIGN -> = [124:53]
+    |   |   `--EXPR -> EXPR [124:55]
+    |   |       `--LITERAL_NEW -> new [124:55]
+    |   |           |--IDENT -> Hashtable [124:59]
+    |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [124:68]
+    |   |           |   |--GENERIC_START -> < [124:68]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [124:69]
+    |   |           |   |   `--IDENT -> String [124:69]
+    |   |           |   |--COMMA -> , [124:75]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [124:77]
+    |   |           |   |   `--IDENT -> Long [124:77]
+    |   |           |   `--GENERIC_END -> > [124:81]
+    |   |           |--LPAREN -> ( [124:82]
+    |   |           |--ELIST -> ELIST [124:83]
+    |   |           `--RPAREN -> ) [124:83]
+    |   `--SEMI -> ; [124:84]
+    |--VARIABLE_DEF -> VARIABLE_DEF [128:4]
+    |   |--MODIFIERS -> MODIFIERS [128:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [125:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * Where to write the log to.\n      [125:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [127:5]
+    |   |   `--LITERAL_PRIVATE -> private [128:4]
+    |   |--TYPE -> TYPE [128:12]
+    |   |   `--IDENT -> OutputStream [128:12]
+    |   |--IDENT -> out [128:25]
+    |   `--SEMI -> ; [128:28]
+    |--CTOR_DEF -> CTOR_DEF [131:4]
+    |   |--MODIFIERS -> MODIFIERS [131:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [130:4]
+    |   |   |   |--COMMENT_CONTENT -> * No arg constructor.  [130:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [130:27]
+    |   |   `--LITERAL_PUBLIC -> public [131:4]
+    |   |--IDENT -> InputAntlr4AstRegressionCassandraInputWithComments [131:11]
+    |   |--LPAREN -> ( [131:61]
+    |   |--PARAMETERS -> PARAMETERS [131:62]
+    |   |--RPAREN -> ) [131:62]
+    |   `--SLIST -> { [131:64]
+    |       `--RCURLY -> } [132:4]
+    |--METHOD_DEF -> METHOD_DEF [135:4]
+    |   |--MODIFIERS -> MODIFIERS [135:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [134:4]
+    |   |   |   |--COMMENT_CONTENT -> * {@inheritDoc}.  [134:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [134:22]
+    |   |   `--LITERAL_PUBLIC -> public [135:4]
+    |   |--TYPE -> TYPE [135:11]
+    |   |   `--LITERAL_VOID -> void [135:11]
+    |   |--IDENT -> setOutput [135:16]
+    |   |--LPAREN -> ( [135:25]
+    |   |--PARAMETERS -> PARAMETERS [135:26]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [135:26]
+    |   |       |--MODIFIERS -> MODIFIERS [135:26]
+    |   |       |   `--FINAL -> final [135:26]
+    |   |       |--TYPE -> TYPE [135:32]
+    |   |       |   `--IDENT -> OutputStream [135:32]
+    |   |       `--IDENT -> out [135:45]
+    |   |--RPAREN -> ) [135:48]
+    |   `--SLIST -> { [135:50]
+    |       |--EXPR -> EXPR [136:17]
+    |       |   `--ASSIGN -> = [136:17]
+    |       |       |--DOT -> . [136:12]
+    |       |       |   |--LITERAL_THIS -> this [136:8]
+    |       |       |   `--IDENT -> out [136:13]
+    |       |       `--IDENT -> out [136:19]
+    |       |--SEMI -> ; [136:22]
+    |       `--RCURLY -> } [137:4]
+    |--METHOD_DEF -> METHOD_DEF [140:4]
+    |   |--MODIFIERS -> MODIFIERS [140:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [139:4]
+    |   |   |   |--COMMENT_CONTENT -> * {@inheritDoc}.  [139:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [139:22]
+    |   |   `--LITERAL_PUBLIC -> public [140:4]
+    |   |--TYPE -> TYPE [140:11]
+    |   |   `--LITERAL_VOID -> void [140:11]
+    |   |--IDENT -> setSystemOutput [140:16]
+    |   |--LPAREN -> ( [140:31]
+    |   |--PARAMETERS -> PARAMETERS [140:32]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [140:32]
+    |   |       |--MODIFIERS -> MODIFIERS [140:32]
+    |   |       |   `--FINAL -> final [140:32]
+    |   |       |--TYPE -> TYPE [140:38]
+    |   |       |   `--IDENT -> String [140:38]
+    |   |       `--IDENT -> out [140:45]
+    |   |--RPAREN -> ) [140:48]
+    |   `--SLIST -> { [140:50]
+    |       |--EXPR -> EXPR [141:20]
+    |       |   `--METHOD_CALL -> ( [141:20]
+    |       |       |--IDENT -> formatOutput [141:8]
+    |       |       |--ELIST -> ELIST [141:21]
+    |       |       |   |--EXPR -> EXPR [141:21]
+    |       |       |   |   `--IDENT -> SYSTEM_OUT [141:21]
+    |       |       |   |--COMMA -> , [141:31]
+    |       |       |   `--EXPR -> EXPR [141:33]
+    |       |       |       `--IDENT -> out [141:33]
+    |       |       `--RPAREN -> ) [141:36]
+    |       |--SEMI -> ; [141:37]
+    |       `--RCURLY -> } [142:4]
+    |--METHOD_DEF -> METHOD_DEF [145:4]
+    |   |--MODIFIERS -> MODIFIERS [145:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [144:4]
+    |   |   |   |--COMMENT_CONTENT -> * {@inheritDoc}.  [144:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [144:22]
+    |   |   `--LITERAL_PUBLIC -> public [145:4]
+    |   |--TYPE -> TYPE [145:11]
+    |   |   `--LITERAL_VOID -> void [145:11]
+    |   |--IDENT -> setSystemError [145:16]
+    |   |--LPAREN -> ( [145:30]
+    |   |--PARAMETERS -> PARAMETERS [145:31]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [145:31]
+    |   |       |--MODIFIERS -> MODIFIERS [145:31]
+    |   |       |   `--FINAL -> final [145:31]
+    |   |       |--TYPE -> TYPE [145:37]
+    |   |       |   `--IDENT -> String [145:37]
+    |   |       `--IDENT -> out [145:44]
+    |   |--RPAREN -> ) [145:47]
+    |   `--SLIST -> { [145:49]
+    |       |--EXPR -> EXPR [146:20]
+    |       |   `--METHOD_CALL -> ( [146:20]
+    |       |       |--IDENT -> formatOutput [146:8]
+    |       |       |--ELIST -> ELIST [146:21]
+    |       |       |   |--EXPR -> EXPR [146:21]
+    |       |       |   |   `--IDENT -> SYSTEM_ERR [146:21]
+    |       |       |   |--COMMA -> , [146:31]
+    |       |       |   `--EXPR -> EXPR [146:33]
+    |       |       |       `--IDENT -> out [146:33]
+    |       |       `--RPAREN -> ) [146:36]
+    |       |--SEMI -> ; [146:37]
+    |       `--RCURLY -> } [147:4]
+    |--METHOD_DEF -> METHOD_DEF [153:4]
+    |   |--MODIFIERS -> MODIFIERS [153:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [149:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * The whole testsuite started.\n     * @param suite the testsuite.\n      [149:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [152:5]
+    |   |   `--LITERAL_PUBLIC -> public [153:4]
+    |   |--TYPE -> TYPE [153:11]
+    |   |   `--LITERAL_VOID -> void [153:11]
+    |   |--IDENT -> startTestSuite [153:16]
+    |   |--LPAREN -> ( [153:30]
+    |   |--PARAMETERS -> PARAMETERS [153:31]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [153:31]
+    |   |       |--MODIFIERS -> MODIFIERS [153:31]
+    |   |       |   `--FINAL -> final [153:31]
+    |   |       |--TYPE -> TYPE [153:37]
+    |   |       |   `--IDENT -> JUnitTest [153:37]
+    |   |       `--IDENT -> suite [153:47]
+    |   |--RPAREN -> ) [153:52]
+    |   `--SLIST -> { [153:54]
+    |       |--EXPR -> EXPR [154:12]
+    |       |   `--ASSIGN -> = [154:12]
+    |       |       |--IDENT -> doc [154:8]
+    |       |       `--METHOD_CALL -> ( [154:46]
+    |       |           |--DOT -> . [154:34]
+    |       |           |   |--METHOD_CALL -> ( [154:32]
+    |       |           |   |   |--IDENT -> getDocumentBuilder [154:14]
+    |       |           |   |   |--ELIST -> ELIST [154:33]
+    |       |           |   |   `--RPAREN -> ) [154:33]
+    |       |           |   `--IDENT -> newDocument [154:35]
+    |       |           |--ELIST -> ELIST [154:47]
+    |       |           `--RPAREN -> ) [154:47]
+    |       |--SEMI -> ; [154:48]
+    |       |--EXPR -> EXPR [155:20]
+    |       |   `--ASSIGN -> = [155:20]
+    |       |       |--IDENT -> rootElement [155:8]
+    |       |       `--METHOD_CALL -> ( [155:39]
+    |       |           |--DOT -> . [155:25]
+    |       |           |   |--IDENT -> doc [155:22]
+    |       |           |   `--IDENT -> createElement [155:26]
+    |       |           |--ELIST -> ELIST [155:40]
+    |       |           |   `--EXPR -> EXPR [155:40]
+    |       |           |       `--IDENT -> TESTSUITE [155:40]
+    |       |           `--RPAREN -> ) [155:49]
+    |       |--SEMI -> ; [155:50]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [156:8]
+    |       |   |--MODIFIERS -> MODIFIERS [156:8]
+    |       |   |--TYPE -> TYPE [156:8]
+    |       |   |   `--IDENT -> String [156:8]
+    |       |   |--IDENT -> n [156:15]
+    |       |   `--ASSIGN -> = [156:17]
+    |       |       `--EXPR -> EXPR [156:32]
+    |       |           `--METHOD_CALL -> ( [156:32]
+    |       |               |--DOT -> . [156:24]
+    |       |               |   |--IDENT -> suite [156:19]
+    |       |               |   `--IDENT -> getName [156:25]
+    |       |               |--ELIST -> ELIST [156:33]
+    |       |               `--RPAREN -> ) [156:33]
+    |       |--SEMI -> ; [156:34]
+    |       |--LITERAL_IF -> if [157:8]
+    |       |   |--LPAREN -> ( [157:11]
+    |       |   |--EXPR -> EXPR [157:22]
+    |       |   |   `--LAND -> && [157:22]
+    |       |   |       |--NOT_EQUAL -> != [157:14]
+    |       |   |       |   |--IDENT -> n [157:12]
+    |       |   |       |   `--LITERAL_NULL -> null [157:17]
+    |       |   |       `--LNOT -> ! [157:25]
+    |       |   |           `--METHOD_CALL -> ( [157:37]
+    |       |   |               |--DOT -> . [157:29]
+    |       |   |               |   |--IDENT -> tag [157:26]
+    |       |   |               |   `--IDENT -> isEmpty [157:30]
+    |       |   |               |--ELIST -> ELIST [157:38]
+    |       |   |               `--RPAREN -> ) [157:38]
+    |       |   |--RPAREN -> ) [157:39]
+    |       |   |--EXPR -> EXPR [158:14]
+    |       |   |   `--ASSIGN -> = [158:14]
+    |       |   |       |--IDENT -> n [158:12]
+    |       |   |       `--PLUS -> + [158:24]
+    |       |   |           |--PLUS -> + [158:18]
+    |       |   |           |   |--IDENT -> n [158:16]
+    |       |   |           |   `--STRING_LITERAL -> "-" [158:20]
+    |       |   |           `--IDENT -> tag [158:26]
+    |       |   `--SEMI -> ; [158:29]
+    |       |--EXPR -> EXPR [159:32]
+    |       |   `--METHOD_CALL -> ( [159:32]
+    |       |       |--DOT -> . [159:19]
+    |       |       |   |--IDENT -> rootElement [159:8]
+    |       |       |   `--IDENT -> setAttribute [159:20]
+    |       |       |--ELIST -> ELIST [159:33]
+    |       |       |   |--EXPR -> EXPR [159:33]
+    |       |       |   |   `--IDENT -> ATTR_NAME [159:33]
+    |       |       |   |--COMMA -> , [159:42]
+    |       |       |   `--EXPR -> EXPR [159:54]
+    |       |       |       `--QUESTION -> ? [159:54]
+    |       |       |           |--EQUAL -> == [159:46]
+    |       |       |           |   |--IDENT -> n [159:44]
+    |       |       |           |   `--LITERAL_NULL -> null [159:49]
+    |       |       |           |--IDENT -> UNKNOWN [159:56]
+    |       |       |           |--COLON -> : [159:64]
+    |       |       |           `--IDENT -> n [159:66]
+    |       |       `--RPAREN -> ) [159:67]
+    |       |--SEMI -> ; [159:68]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [162:8]
+    |       |   |--MODIFIERS -> MODIFIERS [162:8]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [161:8]
+    |       |   |   |   `--COMMENT_CONTENT -> add the timestamp\n [161:10]
+    |       |   |   `--FINAL -> final [162:8]
+    |       |   |--TYPE -> TYPE [162:14]
+    |       |   |   `--IDENT -> String [162:14]
+    |       |   |--IDENT -> timestamp [162:21]
+    |       |   `--ASSIGN -> = [162:31]
+    |       |       `--EXPR -> EXPR [162:49]
+    |       |           `--METHOD_CALL -> ( [162:49]
+    |       |               |--DOT -> . [162:42]
+    |       |               |   |--IDENT -> DateUtils [162:33]
+    |       |               |   `--IDENT -> format [162:43]
+    |       |               |--ELIST -> ELIST [162:50]
+    |       |               |   |--EXPR -> EXPR [162:50]
+    |       |               |   |   `--LITERAL_NEW -> new [162:50]
+    |       |               |   |       |--IDENT -> Date [162:54]
+    |       |               |   |       |--LPAREN -> ( [162:58]
+    |       |               |   |       |--ELIST -> ELIST [162:59]
+    |       |               |   |       `--RPAREN -> ) [162:59]
+    |       |               |   |--COMMA -> , [162:60]
+    |       |               |   `--EXPR -> EXPR [163:25]
+    |       |               |       `--DOT -> . [163:25]
+    |       |               |           |--IDENT -> DateUtils [163:16]
+    |       |               |           `--IDENT -> ISO8601_DATETIME_PATTERN [163:26]
+    |       |               `--RPAREN -> ) [163:50]
+    |       |--SEMI -> ; [163:51]
+    |       |--EXPR -> EXPR [164:32]
+    |       |   `--METHOD_CALL -> ( [164:32]
+    |       |       |--DOT -> . [164:19]
+    |       |       |   |--IDENT -> rootElement [164:8]
+    |       |       |   `--IDENT -> setAttribute [164:20]
+    |       |       |--ELIST -> ELIST [164:33]
+    |       |       |   |--EXPR -> EXPR [164:33]
+    |       |       |   |   `--IDENT -> TIMESTAMP [164:33]
+    |       |       |   |--COMMA -> , [164:42]
+    |       |       |   `--EXPR -> EXPR [164:44]
+    |       |       |       `--IDENT -> timestamp [164:44]
+    |       |       `--RPAREN -> ) [164:53]
+    |       |--SEMI -> ; [164:54]
+    |       |--EXPR -> EXPR [166:32]
+    |       |   `--METHOD_CALL -> ( [166:32]
+    |       |       |--DOT -> . [166:19]
+    |       |       |   |--SINGLE_LINE_COMMENT -> // [165:8]
+    |       |       |   |   `--COMMENT_CONTENT -> and the hostname.\n [165:10]
+    |       |       |   |--IDENT -> rootElement [166:8]
+    |       |       |   `--IDENT -> setAttribute [166:20]
+    |       |       |--ELIST -> ELIST [166:33]
+    |       |       |   |--EXPR -> EXPR [166:33]
+    |       |       |   |   `--IDENT -> HOSTNAME [166:33]
+    |       |       |   |--COMMA -> , [166:41]
+    |       |       |   `--EXPR -> EXPR [166:54]
+    |       |       |       `--METHOD_CALL -> ( [166:54]
+    |       |       |           |--IDENT -> getHostname [166:43]
+    |       |       |           |--ELIST -> ELIST [166:55]
+    |       |       |           `--RPAREN -> ) [166:55]
+    |       |       `--RPAREN -> ) [166:56]
+    |       |--SEMI -> ; [166:57]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [169:8]
+    |       |   |--MODIFIERS -> MODIFIERS [169:8]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [168:8]
+    |       |   |   |   `--COMMENT_CONTENT ->  Output properties\n [168:10]
+    |       |   |   `--FINAL -> final [169:8]
+    |       |   |--TYPE -> TYPE [169:14]
+    |       |   |   `--IDENT -> Element [169:14]
+    |       |   |--IDENT -> propsElement [169:22]
+    |       |   `--ASSIGN -> = [169:35]
+    |       |       `--EXPR -> EXPR [169:54]
+    |       |           `--METHOD_CALL -> ( [169:54]
+    |       |               |--DOT -> . [169:40]
+    |       |               |   |--IDENT -> doc [169:37]
+    |       |               |   `--IDENT -> createElement [169:41]
+    |       |               |--ELIST -> ELIST [169:55]
+    |       |               |   `--EXPR -> EXPR [169:55]
+    |       |               |       `--IDENT -> PROPERTIES [169:55]
+    |       |               `--RPAREN -> ) [169:65]
+    |       |--SEMI -> ; [169:66]
+    |       |--EXPR -> EXPR [170:31]
+    |       |   `--METHOD_CALL -> ( [170:31]
+    |       |       |--DOT -> . [170:19]
+    |       |       |   |--IDENT -> rootElement [170:8]
+    |       |       |   `--IDENT -> appendChild [170:20]
+    |       |       |--ELIST -> ELIST [170:32]
+    |       |       |   `--EXPR -> EXPR [170:32]
+    |       |       |       `--IDENT -> propsElement [170:32]
+    |       |       `--RPAREN -> ) [170:44]
+    |       |--SEMI -> ; [170:45]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [171:8]
+    |       |   |--MODIFIERS -> MODIFIERS [171:8]
+    |       |   |   `--FINAL -> final [171:8]
+    |       |   |--TYPE -> TYPE [171:14]
+    |       |   |   `--IDENT -> Properties [171:14]
+    |       |   |--IDENT -> props [171:25]
+    |       |   `--ASSIGN -> = [171:31]
+    |       |       `--EXPR -> EXPR [171:52]
+    |       |           `--METHOD_CALL -> ( [171:52]
+    |       |               |--DOT -> . [171:38]
+    |       |               |   |--IDENT -> suite [171:33]
+    |       |               |   `--IDENT -> getProperties [171:39]
+    |       |               |--ELIST -> ELIST [171:53]
+    |       |               `--RPAREN -> ) [171:53]
+    |       |--SEMI -> ; [171:54]
+    |       |--LITERAL_IF -> if [172:8]
+    |       |   |--LPAREN -> ( [172:11]
+    |       |   |--EXPR -> EXPR [172:18]
+    |       |   |   `--NOT_EQUAL -> != [172:18]
+    |       |   |       |--IDENT -> props [172:12]
+    |       |   |       `--LITERAL_NULL -> null [172:21]
+    |       |   |--RPAREN -> ) [172:25]
+    |       |   `--SLIST -> { [172:27]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [173:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [173:12]
+    |       |       |   |   `--FINAL -> final [173:12]
+    |       |       |   |--TYPE -> TYPE [173:18]
+    |       |       |   |   `--IDENT -> Enumeration [173:18]
+    |       |       |   |--IDENT -> e [173:30]
+    |       |       |   `--ASSIGN -> = [173:32]
+    |       |       |       `--EXPR -> EXPR [173:53]
+    |       |       |           `--METHOD_CALL -> ( [173:53]
+    |       |       |               |--DOT -> . [173:39]
+    |       |       |               |   |--IDENT -> props [173:34]
+    |       |       |               |   `--IDENT -> propertyNames [173:40]
+    |       |       |               |--ELIST -> ELIST [173:54]
+    |       |       |               `--RPAREN -> ) [173:54]
+    |       |       |--SEMI -> ; [173:55]
+    |       |       |--LITERAL_WHILE -> while [174:12]
+    |       |       |   |--LPAREN -> ( [174:18]
+    |       |       |   |--EXPR -> EXPR [174:36]
+    |       |       |   |   `--METHOD_CALL -> ( [174:36]
+    |       |       |   |       |--DOT -> . [174:20]
+    |       |       |   |       |   |--IDENT -> e [174:19]
+    |       |       |   |       |   `--IDENT -> hasMoreElements [174:21]
+    |       |       |   |       |--ELIST -> ELIST [174:37]
+    |       |       |   |       `--RPAREN -> ) [174:37]
+    |       |       |   |--RPAREN -> ) [174:38]
+    |       |       |   `--SLIST -> { [174:40]
+    |       |       |       |--VARIABLE_DEF -> VARIABLE_DEF [175:16]
+    |       |       |       |   |--MODIFIERS -> MODIFIERS [175:16]
+    |       |       |       |   |   `--FINAL -> final [175:16]
+    |       |       |       |   |--TYPE -> TYPE [175:22]
+    |       |       |       |   |   `--IDENT -> String [175:22]
+    |       |       |       |   |--IDENT -> name [175:29]
+    |       |       |       |   `--ASSIGN -> = [175:34]
+    |       |       |       |       `--EXPR -> EXPR [175:36]
+    |       |       |       |           `--TYPECAST -> ( [175:36]
+    |       |       |       |               |--TYPE -> TYPE [175:37]
+    |       |       |       |               |   `--IDENT -> String [175:37]
+    |       |       |       |               |--RPAREN -> ) [175:43]
+    |       |       |       |               `--METHOD_CALL -> ( [175:58]
+    |       |       |       |                   |--DOT -> . [175:46]
+    |       |       |       |                   |   |--IDENT -> e [175:45]
+    |       |       |       |                   |   `--IDENT -> nextElement [175:47]
+    |       |       |       |                   |--ELIST -> ELIST [175:59]
+    |       |       |       |                   `--RPAREN -> ) [175:59]
+    |       |       |       |--SEMI -> ; [175:60]
+    |       |       |       |--VARIABLE_DEF -> VARIABLE_DEF [176:16]
+    |       |       |       |   |--MODIFIERS -> MODIFIERS [176:16]
+    |       |       |       |   |   `--FINAL -> final [176:16]
+    |       |       |       |   |--TYPE -> TYPE [176:22]
+    |       |       |       |   |   `--IDENT -> Element [176:22]
+    |       |       |       |   |--IDENT -> propElement [176:30]
+    |       |       |       |   `--ASSIGN -> = [176:42]
+    |       |       |       |       `--EXPR -> EXPR [176:61]
+    |       |       |       |           `--METHOD_CALL -> ( [176:61]
+    |       |       |       |               |--DOT -> . [176:47]
+    |       |       |       |               |   |--IDENT -> doc [176:44]
+    |       |       |       |               |   `--IDENT -> createElement [176:48]
+    |       |       |       |               |--ELIST -> ELIST [176:62]
+    |       |       |       |               |   `--EXPR -> EXPR [176:62]
+    |       |       |       |               |       `--IDENT -> PROPERTY [176:62]
+    |       |       |       |               `--RPAREN -> ) [176:70]
+    |       |       |       |--SEMI -> ; [176:71]
+    |       |       |       |--EXPR -> EXPR [177:40]
+    |       |       |       |   `--METHOD_CALL -> ( [177:40]
+    |       |       |       |       |--DOT -> . [177:27]
+    |       |       |       |       |   |--IDENT -> propElement [177:16]
+    |       |       |       |       |   `--IDENT -> setAttribute [177:28]
+    |       |       |       |       |--ELIST -> ELIST [177:41]
+    |       |       |       |       |   |--EXPR -> EXPR [177:41]
+    |       |       |       |       |   |   `--IDENT -> ATTR_NAME [177:41]
+    |       |       |       |       |   |--COMMA -> , [177:50]
+    |       |       |       |       |   `--EXPR -> EXPR [177:52]
+    |       |       |       |       |       `--IDENT -> name [177:52]
+    |       |       |       |       `--RPAREN -> ) [177:56]
+    |       |       |       |--SEMI -> ; [177:57]
+    |       |       |       |--EXPR -> EXPR [178:40]
+    |       |       |       |   `--METHOD_CALL -> ( [178:40]
+    |       |       |       |       |--DOT -> . [178:27]
+    |       |       |       |       |   |--IDENT -> propElement [178:16]
+    |       |       |       |       |   `--IDENT -> setAttribute [178:28]
+    |       |       |       |       |--ELIST -> ELIST [178:41]
+    |       |       |       |       |   |--EXPR -> EXPR [178:41]
+    |       |       |       |       |   |   `--IDENT -> ATTR_VALUE [178:41]
+    |       |       |       |       |   |--COMMA -> , [178:51]
+    |       |       |       |       |   `--EXPR -> EXPR [178:70]
+    |       |       |       |       |       `--METHOD_CALL -> ( [178:70]
+    |       |       |       |       |           |--DOT -> . [178:58]
+    |       |       |       |       |           |   |--IDENT -> props [178:53]
+    |       |       |       |       |           |   `--IDENT -> getProperty [178:59]
+    |       |       |       |       |           |--ELIST -> ELIST [178:71]
+    |       |       |       |       |           |   `--EXPR -> EXPR [178:71]
+    |       |       |       |       |           |       `--IDENT -> name [178:71]
+    |       |       |       |       |           `--RPAREN -> ) [178:75]
+    |       |       |       |       `--RPAREN -> ) [178:76]
+    |       |       |       |--SEMI -> ; [178:77]
+    |       |       |       |--EXPR -> EXPR [179:40]
+    |       |       |       |   `--METHOD_CALL -> ( [179:40]
+    |       |       |       |       |--DOT -> . [179:28]
+    |       |       |       |       |   |--IDENT -> propsElement [179:16]
+    |       |       |       |       |   `--IDENT -> appendChild [179:29]
+    |       |       |       |       |--ELIST -> ELIST [179:41]
+    |       |       |       |       |   `--EXPR -> EXPR [179:41]
+    |       |       |       |       |       `--IDENT -> propElement [179:41]
+    |       |       |       |       `--RPAREN -> ) [179:52]
+    |       |       |       |--SEMI -> ; [179:53]
+    |       |       |       `--RCURLY -> } [180:12]
+    |       |       `--RCURLY -> } [181:8]
+    |       `--RCURLY -> } [182:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [184:4]
+    |   |--MODIFIERS -> MODIFIERS [184:4]
+    |   |   |--LITERAL_PRIVATE -> private [184:4]
+    |   |   |--LITERAL_STATIC -> static [184:12]
+    |   |   `--FINAL -> final [184:19]
+    |   |--TYPE -> TYPE [184:25]
+    |   |   `--IDENT -> String [184:25]
+    |   |--IDENT -> PROPERTIES [184:32]
+    |   |--ASSIGN -> = [184:43]
+    |   |   `--EXPR -> EXPR [184:45]
+    |   |       `--STRING_LITERAL -> "" [184:45]
+    |   `--SEMI -> ; [184:47]
+    |--VARIABLE_DEF -> VARIABLE_DEF [185:4]
+    |   |--MODIFIERS -> MODIFIERS [185:4]
+    |   |   |--LITERAL_PRIVATE -> private [185:4]
+    |   |   |--LITERAL_STATIC -> static [185:12]
+    |   |   `--FINAL -> final [185:19]
+    |   |--TYPE -> TYPE [185:25]
+    |   |   `--IDENT -> String [185:25]
+    |   |--IDENT -> HOSTNAME [185:32]
+    |   |--ASSIGN -> = [185:41]
+    |   |   `--EXPR -> EXPR [185:43]
+    |   |       `--STRING_LITERAL -> "" [185:43]
+    |   `--SEMI -> ; [185:45]
+    |--VARIABLE_DEF -> VARIABLE_DEF [186:4]
+    |   |--MODIFIERS -> MODIFIERS [186:4]
+    |   |   |--LITERAL_PRIVATE -> private [186:4]
+    |   |   |--LITERAL_STATIC -> static [186:12]
+    |   |   `--FINAL -> final [186:19]
+    |   |--TYPE -> TYPE [186:25]
+    |   |   `--IDENT -> String [186:25]
+    |   |--IDENT -> TIMESTAMP [186:32]
+    |   |--ASSIGN -> = [186:42]
+    |   |   `--EXPR -> EXPR [186:44]
+    |   |       `--STRING_LITERAL -> "" [186:44]
+    |   `--SEMI -> ; [186:46]
+    |--VARIABLE_DEF -> VARIABLE_DEF [187:4]
+    |   |--MODIFIERS -> MODIFIERS [187:4]
+    |   |   |--LITERAL_PRIVATE -> private [187:4]
+    |   |   |--LITERAL_STATIC -> static [187:12]
+    |   |   `--FINAL -> final [187:19]
+    |   |--TYPE -> TYPE [187:25]
+    |   |   `--IDENT -> String [187:25]
+    |   |--IDENT -> ATTR_NAME [187:32]
+    |   |--ASSIGN -> = [187:42]
+    |   |   `--EXPR -> EXPR [187:44]
+    |   |       `--STRING_LITERAL -> "" [187:44]
+    |   `--SEMI -> ; [187:46]
+    |--VARIABLE_DEF -> VARIABLE_DEF [188:4]
+    |   |--MODIFIERS -> MODIFIERS [188:4]
+    |   |   |--LITERAL_PRIVATE -> private [188:4]
+    |   |   |--LITERAL_STATIC -> static [188:12]
+    |   |   `--FINAL -> final [188:19]
+    |   |--TYPE -> TYPE [188:25]
+    |   |   `--IDENT -> String [188:25]
+    |   |--IDENT -> PROPERTY [188:32]
+    |   |--ASSIGN -> = [188:41]
+    |   |   `--EXPR -> EXPR [188:43]
+    |   |       `--STRING_LITERAL -> "" [188:43]
+    |   `--SEMI -> ; [188:45]
+    |--VARIABLE_DEF -> VARIABLE_DEF [189:4]
+    |   |--MODIFIERS -> MODIFIERS [189:4]
+    |   |   |--LITERAL_PRIVATE -> private [189:4]
+    |   |   |--LITERAL_STATIC -> static [189:12]
+    |   |   `--FINAL -> final [189:19]
+    |   |--TYPE -> TYPE [189:25]
+    |   |   `--IDENT -> String [189:25]
+    |   |--IDENT -> ATTR_VALUE [189:32]
+    |   |--ASSIGN -> = [189:43]
+    |   |   `--EXPR -> EXPR [189:45]
+    |   |       `--STRING_LITERAL -> "" [189:45]
+    |   `--SEMI -> ; [189:47]
+    |--CLASS_DEF -> CLASS_DEF [191:4]
+    |   |--MODIFIERS -> MODIFIERS [191:4]
+    |   |--LITERAL_CLASS -> class [191:4]
+    |   |--IDENT -> JUnitTest [191:10]
+    |   `--OBJBLOCK -> OBJBLOCK [191:20]
+    |       |--LCURLY -> { [191:20]
+    |       |--METHOD_DEF -> METHOD_DEF [192:8]
+    |       |   |--MODIFIERS -> MODIFIERS [192:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [192:8]
+    |       |   |--TYPE -> TYPE [192:15]
+    |       |   |   `--IDENT -> String [192:15]
+    |       |   |--IDENT -> getName [192:22]
+    |       |   |--LPAREN -> ( [192:29]
+    |       |   |--PARAMETERS -> PARAMETERS [192:30]
+    |       |   |--RPAREN -> ) [192:30]
+    |       |   `--SLIST -> { [192:32]
+    |       |       |--LITERAL_RETURN -> return [193:12]
+    |       |       |   |--EXPR -> EXPR [193:19]
+    |       |       |   |   `--LITERAL_NULL -> null [193:19]
+    |       |       |   `--SEMI -> ; [193:23]
+    |       |       `--RCURLY -> } [194:8]
+    |       |--METHOD_DEF -> METHOD_DEF [196:8]
+    |       |   |--MODIFIERS -> MODIFIERS [196:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [196:8]
+    |       |   |--TYPE -> TYPE [196:15]
+    |       |   |   `--IDENT -> Properties [196:15]
+    |       |   |--IDENT -> getProperties [196:26]
+    |       |   |--LPAREN -> ( [196:39]
+    |       |   |--PARAMETERS -> PARAMETERS [196:40]
+    |       |   |--RPAREN -> ) [196:40]
+    |       |   `--SLIST -> { [196:42]
+    |       |       |--LITERAL_RETURN -> return [197:12]
+    |       |       |   |--EXPR -> EXPR [197:19]
+    |       |       |   |   `--LITERAL_NULL -> null [197:19]
+    |       |       |   `--SEMI -> ; [197:23]
+    |       |       `--RCURLY -> } [198:8]
+    |       |--METHOD_DEF -> METHOD_DEF [200:8]
+    |       |   |--MODIFIERS -> MODIFIERS [200:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [200:8]
+    |       |   |--TYPE -> TYPE [200:15]
+    |       |   |   `--IDENT -> String [200:15]
+    |       |   |--IDENT -> failureCount [200:22]
+    |       |   |--LPAREN -> ( [200:34]
+    |       |   |--PARAMETERS -> PARAMETERS [200:35]
+    |       |   |--RPAREN -> ) [200:35]
+    |       |   `--SLIST -> { [200:37]
+    |       |       |--LITERAL_RETURN -> return [201:12]
+    |       |       |   |--EXPR -> EXPR [201:19]
+    |       |       |   |   `--LITERAL_NULL -> null [201:19]
+    |       |       |   `--SEMI -> ; [201:23]
+    |       |       `--RCURLY -> } [202:8]
+    |       |--METHOD_DEF -> METHOD_DEF [204:8]
+    |       |   |--MODIFIERS -> MODIFIERS [204:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [204:8]
+    |       |   |--TYPE -> TYPE [204:15]
+    |       |   |   `--IDENT -> String [204:15]
+    |       |   |--IDENT -> getRunTime [204:22]
+    |       |   |--LPAREN -> ( [204:32]
+    |       |   |--PARAMETERS -> PARAMETERS [204:33]
+    |       |   |--RPAREN -> ) [204:33]
+    |       |   `--SLIST -> { [204:35]
+    |       |       |--LITERAL_RETURN -> return [205:12]
+    |       |       |   |--EXPR -> EXPR [205:19]
+    |       |       |   |   `--LITERAL_NULL -> null [205:19]
+    |       |       |   `--SEMI -> ; [205:23]
+    |       |       `--RCURLY -> } [206:8]
+    |       `--RCURLY -> } [207:4]
+    |--METHOD_DEF -> METHOD_DEF [213:4]
+    |   |--MODIFIERS -> MODIFIERS [213:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [209:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * get the local hostname\n     * @return the name of the local host, or "localhost" if we cannot work it out\n      [209:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [212:5]
+    |   |   `--LITERAL_PRIVATE -> private [213:4]
+    |   |--TYPE -> TYPE [213:12]
+    |   |   `--IDENT -> String [213:12]
+    |   |--IDENT -> getHostname [213:19]
+    |   |--LPAREN -> ( [213:30]
+    |   |--PARAMETERS -> PARAMETERS [213:31]
+    |   |--RPAREN -> ) [213:31]
+    |   `--SLIST -> { [213:34]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [214:8]
+    |       |   |--MODIFIERS -> MODIFIERS [214:8]
+    |       |   |--TYPE -> TYPE [214:8]
+    |       |   |   `--IDENT -> String [214:8]
+    |       |   |--IDENT -> hostname [214:15]
+    |       |   `--ASSIGN -> = [214:24]
+    |       |       `--EXPR -> EXPR [214:26]
+    |       |           `--STRING_LITERAL -> "localhost" [214:26]
+    |       |--SEMI -> ; [214:37]
+    |       |--LITERAL_TRY -> try [215:8]
+    |       |   |--SLIST -> { [215:12]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [216:12]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [216:12]
+    |       |   |   |   |   `--FINAL -> final [216:12]
+    |       |   |   |   |--TYPE -> TYPE [216:18]
+    |       |   |   |   |   `--IDENT -> InetAddress [216:18]
+    |       |   |   |   |--IDENT -> localHost [216:30]
+    |       |   |   |   `--ASSIGN -> = [216:40]
+    |       |   |   |       `--EXPR -> EXPR [216:66]
+    |       |   |   |           `--METHOD_CALL -> ( [216:66]
+    |       |   |   |               |--DOT -> . [216:53]
+    |       |   |   |               |   |--IDENT -> InetAddress [216:42]
+    |       |   |   |               |   `--IDENT -> getLocalHost [216:54]
+    |       |   |   |               |--ELIST -> ELIST [216:67]
+    |       |   |   |               `--RPAREN -> ) [216:67]
+    |       |   |   |--SEMI -> ; [216:68]
+    |       |   |   |--LITERAL_IF -> if [217:12]
+    |       |   |   |   |--LPAREN -> ( [217:15]
+    |       |   |   |   |--EXPR -> EXPR [217:26]
+    |       |   |   |   |   `--NOT_EQUAL -> != [217:26]
+    |       |   |   |   |       |--IDENT -> localHost [217:16]
+    |       |   |   |   |       `--LITERAL_NULL -> null [217:29]
+    |       |   |   |   |--RPAREN -> ) [217:33]
+    |       |   |   |   `--SLIST -> { [217:35]
+    |       |   |   |       |--EXPR -> EXPR [218:25]
+    |       |   |   |       |   `--ASSIGN -> = [218:25]
+    |       |   |   |       |       |--IDENT -> hostname [218:16]
+    |       |   |   |       |       `--METHOD_CALL -> ( [218:48]
+    |       |   |   |       |           |--DOT -> . [218:36]
+    |       |   |   |       |           |   |--IDENT -> localHost [218:27]
+    |       |   |   |       |           |   `--IDENT -> getHostName [218:37]
+    |       |   |   |       |           |--ELIST -> ELIST [218:49]
+    |       |   |   |       |           `--RPAREN -> ) [218:49]
+    |       |   |   |       |--SEMI -> ; [218:50]
+    |       |   |   |       `--RCURLY -> } [219:12]
+    |       |   |   `--RCURLY -> } [220:8]
+    |       |   `--LITERAL_CATCH -> catch [220:10]
+    |       |       |--LPAREN -> ( [220:16]
+    |       |       |--PARAMETER_DEF -> PARAMETER_DEF [220:17]
+    |       |       |   |--MODIFIERS -> MODIFIERS [220:17]
+    |       |       |   |   `--FINAL -> final [220:17]
+    |       |       |   |--TYPE -> TYPE [220:23]
+    |       |       |   |   `--IDENT -> UnknownHostException [220:23]
+    |       |       |   `--IDENT -> e [220:44]
+    |       |       |--RPAREN -> ) [220:45]
+    |       |       `--SLIST -> { [220:47]
+    |       |           |--SINGLE_LINE_COMMENT -> // [221:12]
+    |       |           |   `--COMMENT_CONTENT ->  fall back to default 'localhost'\n [221:14]
+    |       |           `--RCURLY -> } [222:8]
+    |       |--LITERAL_RETURN -> return [223:8]
+    |       |   |--EXPR -> EXPR [223:15]
+    |       |   |   `--IDENT -> hostname [223:15]
+    |       |   `--SEMI -> ; [223:23]
+    |       `--RCURLY -> } [224:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [226:4]
+    |   |--MODIFIERS -> MODIFIERS [226:4]
+    |   |   |--LITERAL_PRIVATE -> private [226:4]
+    |   |   |--LITERAL_STATIC -> static [226:12]
+    |   |   `--FINAL -> final [226:19]
+    |   |--TYPE -> TYPE [226:25]
+    |   |   `--IDENT -> String [226:25]
+    |   |--IDENT -> ATTR_TESTS [226:32]
+    |   |--ASSIGN -> = [226:43]
+    |   |   `--EXPR -> EXPR [226:45]
+    |   |       `--STRING_LITERAL -> "" [226:45]
+    |   `--SEMI -> ; [226:47]
+    |--VARIABLE_DEF -> VARIABLE_DEF [227:4]
+    |   |--MODIFIERS -> MODIFIERS [227:4]
+    |   |   |--LITERAL_PRIVATE -> private [227:4]
+    |   |   |--LITERAL_STATIC -> static [227:12]
+    |   |   `--FINAL -> final [227:19]
+    |   |--TYPE -> TYPE [227:25]
+    |   |   `--IDENT -> String [227:25]
+    |   |--IDENT -> ATTR_FAILURES [227:32]
+    |   |--ASSIGN -> = [227:46]
+    |   |   `--EXPR -> EXPR [227:48]
+    |   |       `--STRING_LITERAL -> "" [227:48]
+    |   `--SEMI -> ; [227:50]
+    |--VARIABLE_DEF -> VARIABLE_DEF [228:4]
+    |   |--MODIFIERS -> MODIFIERS [228:4]
+    |   |   |--LITERAL_PRIVATE -> private [228:4]
+    |   |   |--LITERAL_STATIC -> static [228:12]
+    |   |   `--FINAL -> final [228:19]
+    |   |--TYPE -> TYPE [228:25]
+    |   |   `--IDENT -> String [228:25]
+    |   |--IDENT -> ATTR_SKIPPED [228:32]
+    |   |--ASSIGN -> = [228:45]
+    |   |   `--EXPR -> EXPR [228:47]
+    |   |       `--STRING_LITERAL -> "" [228:47]
+    |   `--SEMI -> ; [228:49]
+    |--METHOD_DEF -> METHOD_DEF [235:4]
+    |   |--MODIFIERS -> MODIFIERS [235:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [230:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * The whole testsuite ended.\n     * @param suite the testsuite.\n     * @throws BuildException on error.\n      [230:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [234:5]
+    |   |   `--LITERAL_PUBLIC -> public [235:4]
+    |   |--TYPE -> TYPE [235:11]
+    |   |   `--LITERAL_VOID -> void [235:11]
+    |   |--IDENT -> endTestSuite [235:16]
+    |   |--LPAREN -> ( [235:28]
+    |   |--PARAMETERS -> PARAMETERS [235:29]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [235:29]
+    |   |       |--MODIFIERS -> MODIFIERS [235:29]
+    |   |       |   `--FINAL -> final [235:29]
+    |   |       |--TYPE -> TYPE [235:35]
+    |   |       |   `--IDENT -> JUnitTest [235:35]
+    |   |       `--IDENT -> suite [235:45]
+    |   |--RPAREN -> ) [235:50]
+    |   |--LITERAL_THROWS -> throws [235:52]
+    |   |   `--IDENT -> BuildException [235:59]
+    |   `--SLIST -> { [235:74]
+    |       |--EXPR -> EXPR [236:32]
+    |       |   `--METHOD_CALL -> ( [236:32]
+    |       |       |--DOT -> . [236:19]
+    |       |       |   |--IDENT -> rootElement [236:8]
+    |       |       |   `--IDENT -> setAttribute [236:20]
+    |       |       |--ELIST -> ELIST [236:33]
+    |       |       |   |--EXPR -> EXPR [236:33]
+    |       |       |   |   `--IDENT -> ATTR_SKIPPED [236:33]
+    |       |       |   |--COMMA -> , [236:45]
+    |       |       |   `--EXPR -> EXPR [236:50]
+    |       |       |       `--PLUS -> + [236:50]
+    |       |       |           |--STRING_LITERAL -> "" [236:47]
+    |       |       |           `--METHOD_CALL -> ( [236:70]
+    |       |       |               |--DOT -> . [236:57]
+    |       |       |               |   |--IDENT -> suite [236:52]
+    |       |       |               |   `--IDENT -> failureCount [236:58]
+    |       |       |               |--ELIST -> ELIST [236:71]
+    |       |       |               `--RPAREN -> ) [236:71]
+    |       |       `--RPAREN -> ) [236:72]
+    |       |--SEMI -> ; [236:73]
+    |       |--EXPR -> EXPR [237:32]
+    |       |   `--METHOD_CALL -> ( [237:32]
+    |       |       |--DOT -> . [237:19]
+    |       |       |   |--IDENT -> rootElement [237:8]
+    |       |       |   `--IDENT -> setAttribute [237:20]
+    |       |       |--ELIST -> ELIST [238:16]
+    |       |       |   |--EXPR -> EXPR [238:16]
+    |       |       |   |   `--IDENT -> ATTR_TESTS [238:16]
+    |       |       |   |--COMMA -> , [238:26]
+    |       |       |   `--EXPR -> EXPR [238:31]
+    |       |       |       `--PLUS -> + [238:31]
+    |       |       |           |--STRING_LITERAL -> "" [238:28]
+    |       |       |           |--LPAREN -> ( [238:33]
+    |       |       |           |--IDENT -> ONE_SECOND [238:34]
+    |       |       |           `--RPAREN -> ) [238:44]
+    |       |       `--RPAREN -> ) [238:45]
+    |       |--SEMI -> ; [238:46]
+    |       |--LITERAL_IF -> if [239:8]
+    |       |   |--LPAREN -> ( [239:11]
+    |       |   |--EXPR -> EXPR [239:16]
+    |       |   |   `--NOT_EQUAL -> != [239:16]
+    |       |   |       |--IDENT -> out [239:12]
+    |       |   |       `--LITERAL_NULL -> null [239:19]
+    |       |   |--RPAREN -> ) [239:23]
+    |       |   `--SLIST -> { [239:25]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [240:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [240:12]
+    |       |       |   |--TYPE -> TYPE [240:12]
+    |       |       |   |   `--IDENT -> Writer [240:12]
+    |       |       |   |--IDENT -> wri [240:19]
+    |       |       |   `--ASSIGN -> = [240:23]
+    |       |       |       `--EXPR -> EXPR [240:25]
+    |       |       |           `--LITERAL_NULL -> null [240:25]
+    |       |       |--SEMI -> ; [240:29]
+    |       |       |--LITERAL_TRY -> try [241:12]
+    |       |       |   |--SLIST -> { [241:16]
+    |       |       |   |   |--EXPR -> EXPR [242:20]
+    |       |       |   |   |   `--ASSIGN -> = [242:20]
+    |       |       |   |   |       |--IDENT -> wri [242:16]
+    |       |       |   |   |       `--LITERAL_NEW -> new [242:22]
+    |       |       |   |   |           |--IDENT -> BufferedWriter [242:26]
+    |       |       |   |   |           |--LPAREN -> ( [242:40]
+    |       |       |   |   |           |--ELIST -> ELIST [242:41]
+    |       |       |   |   |           |   `--EXPR -> EXPR [242:41]
+    |       |       |   |   |           |       `--LITERAL_NEW -> new [242:41]
+    |       |       |   |   |           |           |--IDENT -> OutputStreamWriter [242:45]
+    |       |       |   |   |           |           |--LPAREN -> ( [242:63]
+    |       |       |   |   |           |           |--ELIST -> ELIST [242:64]
+    |       |       |   |   |           |           |   |--EXPR -> EXPR [242:64]
+    |       |       |   |   |           |           |   |   `--IDENT -> out [242:64]
+    |       |       |   |   |           |           |   |--COMMA -> , [242:67]
+    |       |       |   |   |           |           |   `--EXPR -> EXPR [242:69]
+    |       |       |   |   |           |           |       `--STRING_LITERAL -> "UTF8" [242:69]
+    |       |       |   |   |           |           `--RPAREN -> ) [242:75]
+    |       |       |   |   |           `--RPAREN -> ) [242:76]
+    |       |       |   |   |--SEMI -> ; [242:77]
+    |       |       |   |   |--EXPR -> EXPR [243:25]
+    |       |       |   |   |   `--METHOD_CALL -> ( [243:25]
+    |       |       |   |   |       |--DOT -> . [243:19]
+    |       |       |   |   |       |   |--IDENT -> wri [243:16]
+    |       |       |   |   |       |   `--IDENT -> write [243:20]
+    |       |       |   |   |       |--ELIST -> ELIST [243:26]
+    |       |       |   |   |       |   `--EXPR -> EXPR [243:26]
+    |       |       |   |   |       |       `--STRING_LITERAL -> "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" [243:26]
+    |       |       |   |   |       `--RPAREN -> ) [243:73]
+    |       |       |   |   |--SEMI -> ; [243:74]
+    |       |       |   |   |--EXPR -> EXPR [244:46]
+    |       |       |   |   |   `--METHOD_CALL -> ( [244:46]
+    |       |       |   |   |       |--DOT -> . [244:40]
+    |       |       |   |   |       |   |--LPAREN -> ( [244:16]
+    |       |       |   |   |       |   |--LITERAL_NEW -> new [244:17]
+    |       |       |   |   |       |   |   |--IDENT -> DOMElementWriter [244:21]
+    |       |       |   |   |       |   |   |--LPAREN -> ( [244:37]
+    |       |       |   |   |       |   |   |--ELIST -> ELIST [244:38]
+    |       |       |   |   |       |   |   `--RPAREN -> ) [244:38]
+    |       |       |   |   |       |   |--RPAREN -> ) [244:39]
+    |       |       |   |   |       |   `--IDENT -> write [244:41]
+    |       |       |   |   |       |--ELIST -> ELIST [244:47]
+    |       |       |   |   |       |   |--EXPR -> EXPR [244:47]
+    |       |       |   |   |       |   |   `--IDENT -> rootElement [244:47]
+    |       |       |   |   |       |   |--COMMA -> , [244:58]
+    |       |       |   |   |       |   |--EXPR -> EXPR [244:60]
+    |       |       |   |   |       |   |   `--IDENT -> wri [244:60]
+    |       |       |   |   |       |   |--COMMA -> , [244:63]
+    |       |       |   |   |       |   |--EXPR -> EXPR [244:65]
+    |       |       |   |   |       |   |   `--NUM_INT -> 0 [244:65]
+    |       |       |   |   |       |   |--COMMA -> , [244:66]
+    |       |       |   |   |       |   `--EXPR -> EXPR [244:68]
+    |       |       |   |   |       |       `--STRING_LITERAL -> "  " [244:68]
+    |       |       |   |   |       `--RPAREN -> ) [244:72]
+    |       |       |   |   |--SEMI -> ; [244:73]
+    |       |       |   |   `--RCURLY -> } [245:12]
+    |       |       |   |--LITERAL_CATCH -> catch [245:14]
+    |       |       |   |   |--LPAREN -> ( [245:20]
+    |       |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [245:21]
+    |       |       |   |   |   |--MODIFIERS -> MODIFIERS [245:21]
+    |       |       |   |   |   |   `--FINAL -> final [245:21]
+    |       |       |   |   |   |--TYPE -> TYPE [245:27]
+    |       |       |   |   |   |   `--IDENT -> IOException [245:27]
+    |       |       |   |   |   `--IDENT -> exc [245:39]
+    |       |       |   |   |--RPAREN -> ) [245:42]
+    |       |       |   |   `--SLIST -> { [245:44]
+    |       |       |   |       |--LITERAL_THROW -> throw [246:16]
+    |       |       |   |       |   |--EXPR -> EXPR [246:22]
+    |       |       |   |       |   |   `--LITERAL_NEW -> new [246:22]
+    |       |       |   |       |   |       |--IDENT -> BuildException [246:26]
+    |       |       |   |       |   |       |--LPAREN -> ( [246:40]
+    |       |       |   |       |   |       |--ELIST -> ELIST [246:41]
+    |       |       |   |       |   |       |   |--EXPR -> EXPR [246:41]
+    |       |       |   |       |   |       |   |   `--STRING_LITERAL -> "Unable to write log file" [246:41]
+    |       |       |   |       |   |       |   |--COMMA -> , [246:67]
+    |       |       |   |       |   |       |   `--EXPR -> EXPR [246:69]
+    |       |       |   |       |   |       |       `--IDENT -> exc [246:69]
+    |       |       |   |       |   |       `--RPAREN -> ) [246:72]
+    |       |       |   |       |   `--SEMI -> ; [246:73]
+    |       |       |   |       `--RCURLY -> } [247:12]
+    |       |       |   `--LITERAL_FINALLY -> finally [247:14]
+    |       |       |       `--SLIST -> { [247:22]
+    |       |       |           |--LITERAL_IF -> if [248:16]
+    |       |       |           |   |--LPAREN -> ( [248:19]
+    |       |       |           |   |--EXPR -> EXPR [248:24]
+    |       |       |           |   |   `--NOT_EQUAL -> != [248:24]
+    |       |       |           |   |       |--IDENT -> wri [248:20]
+    |       |       |           |   |       `--LITERAL_NULL -> null [248:27]
+    |       |       |           |   |--RPAREN -> ) [248:31]
+    |       |       |           |   `--SLIST -> { [248:33]
+    |       |       |           |       |--LITERAL_TRY -> try [249:20]
+    |       |       |           |       |   |--SLIST -> { [249:24]
+    |       |       |           |       |   |   |--EXPR -> EXPR [250:33]
+    |       |       |           |       |   |   |   `--METHOD_CALL -> ( [250:33]
+    |       |       |           |       |   |   |       |--DOT -> . [250:27]
+    |       |       |           |       |   |   |       |   |--IDENT -> wri [250:24]
+    |       |       |           |       |   |   |       |   `--IDENT -> flush [250:28]
+    |       |       |           |       |   |   |       |--ELIST -> ELIST [250:34]
+    |       |       |           |       |   |   |       `--RPAREN -> ) [250:34]
+    |       |       |           |       |   |   |--SEMI -> ; [250:35]
+    |       |       |           |       |   |   `--RCURLY -> } [251:20]
+    |       |       |           |       |   `--LITERAL_CATCH -> catch [251:22]
+    |       |       |           |       |       |--LPAREN -> ( [251:28]
+    |       |       |           |       |       |--PARAMETER_DEF -> PARAMETER_DEF [251:29]
+    |       |       |           |       |       |   |--MODIFIERS -> MODIFIERS [251:29]
+    |       |       |           |       |       |   |   `--FINAL -> final [251:29]
+    |       |       |           |       |       |   |--TYPE -> TYPE [251:35]
+    |       |       |           |       |       |   |   `--IDENT -> IOException [251:35]
+    |       |       |           |       |       |   `--IDENT -> ex [251:47]
+    |       |       |           |       |       |--RPAREN -> ) [251:49]
+    |       |       |           |       |       `--SLIST -> { [251:51]
+    |       |       |           |       |           |--SINGLE_LINE_COMMENT -> // [252:24]
+    |       |       |           |       |           |   `--COMMENT_CONTENT ->  ignore\n [252:26]
+    |       |       |           |       |           `--RCURLY -> } [253:20]
+    |       |       |           |       `--RCURLY -> } [254:16]
+    |       |       |           |--LITERAL_IF -> if [255:16]
+    |       |       |           |   |--LPAREN -> ( [255:19]
+    |       |       |           |   |--EXPR -> EXPR [255:38]
+    |       |       |           |   |   `--LAND -> && [255:38]
+    |       |       |           |   |       |--NOT_EQUAL -> != [255:24]
+    |       |       |           |   |       |   |--IDENT -> out [255:20]
+    |       |       |           |   |       |   `--DOT -> . [255:33]
+    |       |       |           |   |       |       |--IDENT -> System [255:27]
+    |       |       |           |   |       |       `--IDENT -> out [255:34]
+    |       |       |           |   |       `--NOT_EQUAL -> != [255:45]
+    |       |       |           |   |           |--IDENT -> out [255:41]
+    |       |       |           |   |           `--DOT -> . [255:54]
+    |       |       |           |   |               |--IDENT -> System [255:48]
+    |       |       |           |   |               `--IDENT -> err [255:55]
+    |       |       |           |   |--RPAREN -> ) [255:58]
+    |       |       |           |   `--SLIST -> { [255:60]
+    |       |       |           |       |--EXPR -> EXPR [256:35]
+    |       |       |           |       |   `--METHOD_CALL -> ( [256:35]
+    |       |       |           |       |       |--DOT -> . [256:29]
+    |       |       |           |       |       |   |--IDENT -> FileUtils [256:20]
+    |       |       |           |       |       |   `--IDENT -> close [256:30]
+    |       |       |           |       |       |--ELIST -> ELIST [256:36]
+    |       |       |           |       |       |   `--EXPR -> EXPR [256:36]
+    |       |       |           |       |       |       `--IDENT -> wri [256:36]
+    |       |       |           |       |       `--RPAREN -> ) [256:39]
+    |       |       |           |       |--SEMI -> ; [256:40]
+    |       |       |           |       `--RCURLY -> } [257:16]
+    |       |       |           `--RCURLY -> } [258:12]
+    |       |       `--RCURLY -> } [259:8]
+    |       `--RCURLY -> } [260:4]
+    |--METHOD_DEF -> METHOD_DEF [268:4]
+    |   |--MODIFIERS -> MODIFIERS [268:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [262:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * Interface TestListener.\n     *\n     * <p>A new Test is started.\n     * @param t the test.\n      [262:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [267:5]
+    |   |   `--LITERAL_PUBLIC -> public [268:4]
+    |   |--TYPE -> TYPE [268:11]
+    |   |   `--LITERAL_VOID -> void [268:11]
+    |   |--IDENT -> startTest [268:16]
+    |   |--LPAREN -> ( [268:25]
+    |   |--PARAMETERS -> PARAMETERS [268:26]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [268:26]
+    |   |       |--MODIFIERS -> MODIFIERS [268:26]
+    |   |       |   `--FINAL -> final [268:26]
+    |   |       |--TYPE -> TYPE [268:32]
+    |   |       |   `--IDENT -> Test [268:32]
+    |   |       `--IDENT -> t [268:37]
+    |   |--RPAREN -> ) [268:38]
+    |   `--SLIST -> { [268:40]
+    |       |--EXPR -> EXPR [269:22]
+    |       |   `--METHOD_CALL -> ( [269:22]
+    |       |       |--DOT -> . [269:18]
+    |       |       |   |--IDENT -> testStarts [269:8]
+    |       |       |   `--IDENT -> put [269:19]
+    |       |       |--ELIST -> ELIST [269:40]
+    |       |       |   |--EXPR -> EXPR [269:40]
+    |       |       |   |   `--METHOD_CALL -> ( [269:40]
+    |       |       |   |       |--IDENT -> createDescription [269:23]
+    |       |       |   |       |--ELIST -> ELIST [269:41]
+    |       |       |   |       |   `--EXPR -> EXPR [269:41]
+    |       |       |   |       |       `--IDENT -> t [269:41]
+    |       |       |   |       `--RPAREN -> ) [269:42]
+    |       |       |   |--COMMA -> , [269:43]
+    |       |       |   `--EXPR -> EXPR [270:40]
+    |       |       |       `--METHOD_CALL -> ( [270:40]
+    |       |       |           |--DOT -> . [270:22]
+    |       |       |           |   |--IDENT -> System [270:16]
+    |       |       |           |   `--IDENT -> currentTimeMillis [270:23]
+    |       |       |           |--ELIST -> ELIST [270:41]
+    |       |       |           `--RPAREN -> ) [270:41]
+    |       |       `--RPAREN -> ) [270:42]
+    |       |--SEMI -> ; [270:43]
+    |       `--RCURLY -> } [271:4]
+    |--METHOD_DEF -> METHOD_DEF [273:4]
+    |   |--MODIFIERS -> MODIFIERS [273:4]
+    |   |   |--LITERAL_PRIVATE -> private [273:4]
+    |   |   `--LITERAL_STATIC -> static [273:12]
+    |   |--TYPE -> TYPE [273:19]
+    |   |   `--IDENT -> String [273:19]
+    |   |--IDENT -> createDescription [273:26]
+    |   |--LPAREN -> ( [273:43]
+    |   |--PARAMETERS -> PARAMETERS [273:44]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [273:44]
+    |   |       |--MODIFIERS -> MODIFIERS [273:44]
+    |   |       |   `--FINAL -> final [273:44]
+    |   |       |--TYPE -> TYPE [273:50]
+    |   |       |   `--IDENT -> Test [273:50]
+    |   |       `--IDENT -> test [273:55]
+    |   |--RPAREN -> ) [273:59]
+    |   |--LITERAL_THROWS -> throws [273:61]
+    |   |   `--IDENT -> BuildException [273:68]
+    |   `--SLIST -> { [273:83]
+    |       |--LITERAL_RETURN -> return [274:8]
+    |       |   |--EXPR -> EXPR [274:15]
+    |       |   |   `--LITERAL_NULL -> null [274:15]
+    |       |   `--SEMI -> ; [274:19]
+    |       `--RCURLY -> } [275:4]
+    |--METHOD_DEF -> METHOD_DEF [283:4]
+    |   |--MODIFIERS -> MODIFIERS [283:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [277:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * Interface TestListener.\n     *\n     * <p>A Test is finished.\n     * @param test the test.\n      [277:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [282:5]
+    |   |   `--LITERAL_PUBLIC -> public [283:4]
+    |   |--TYPE -> TYPE [283:11]
+    |   |   `--LITERAL_VOID -> void [283:11]
+    |   |--IDENT -> endTest [283:16]
+    |   |--LPAREN -> ( [283:23]
+    |   |--PARAMETERS -> PARAMETERS [283:24]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [283:24]
+    |   |       |--MODIFIERS -> MODIFIERS [283:24]
+    |   |       |   `--FINAL -> final [283:24]
+    |   |       |--TYPE -> TYPE [283:30]
+    |   |       |   `--IDENT -> Test [283:30]
+    |   |       `--IDENT -> test [283:35]
+    |   |--RPAREN -> ) [283:39]
+    |   `--SLIST -> { [283:41]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [284:8]
+    |       |   |--MODIFIERS -> MODIFIERS [284:8]
+    |       |   |   `--FINAL -> final [284:8]
+    |       |   |--TYPE -> TYPE [284:14]
+    |       |   |   `--IDENT -> String [284:14]
+    |       |   |--IDENT -> testDescription [284:21]
+    |       |   `--ASSIGN -> = [284:37]
+    |       |       `--EXPR -> EXPR [284:56]
+    |       |           `--METHOD_CALL -> ( [284:56]
+    |       |               |--IDENT -> createDescription [284:39]
+    |       |               |--ELIST -> ELIST [284:57]
+    |       |               |   `--EXPR -> EXPR [284:57]
+    |       |               |       `--IDENT -> test [284:57]
+    |       |               `--RPAREN -> ) [284:61]
+    |       |--SEMI -> ; [284:62]
+    |       |--SINGLE_LINE_COMMENT -> // [286:8]
+    |       |   `--COMMENT_CONTENT ->  Fix for bug #5637 - if a junit.extensions.TestSetup is\n [286:10]
+    |       |--SINGLE_LINE_COMMENT -> // [287:8]
+    |       |   `--COMMENT_CONTENT ->  used and throws an exception during setUp then startTest\n [287:10]
+    |       |--SINGLE_LINE_COMMENT -> // [288:8]
+    |       |   `--COMMENT_CONTENT ->  would never have been called\n [288:10]
+    |       |--LITERAL_IF -> if [289:8]
+    |       |   |--LPAREN -> ( [289:11]
+    |       |   |--EXPR -> EXPR [289:12]
+    |       |   |   `--LNOT -> ! [289:12]
+    |       |   |       `--METHOD_CALL -> ( [289:35]
+    |       |   |           |--DOT -> . [289:23]
+    |       |   |           |   |--IDENT -> testStarts [289:13]
+    |       |   |           |   `--IDENT -> containsKey [289:24]
+    |       |   |           |--ELIST -> ELIST [289:36]
+    |       |   |           |   `--EXPR -> EXPR [289:36]
+    |       |   |           |       `--IDENT -> testDescription [289:36]
+    |       |   |           `--RPAREN -> ) [289:51]
+    |       |   |--RPAREN -> ) [289:52]
+    |       |   `--SLIST -> { [289:54]
+    |       |       |--EXPR -> EXPR [290:21]
+    |       |       |   `--METHOD_CALL -> ( [290:21]
+    |       |       |       |--IDENT -> startTest [290:12]
+    |       |       |       |--ELIST -> ELIST [290:22]
+    |       |       |       |   `--EXPR -> EXPR [290:22]
+    |       |       |       |       `--IDENT -> test [290:22]
+    |       |       |       `--RPAREN -> ) [290:26]
+    |       |       |--SEMI -> ; [290:27]
+    |       |       `--RCURLY -> } [291:8]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [292:8]
+    |       |   |--MODIFIERS -> MODIFIERS [292:8]
+    |       |   |--TYPE -> TYPE [292:8]
+    |       |   |   `--IDENT -> Element [292:8]
+    |       |   `--IDENT -> currentTest [292:16]
+    |       |--SEMI -> ; [292:27]
+    |       |--LITERAL_IF -> if [293:8]
+    |       |   |--LPAREN -> ( [293:11]
+    |       |   |--EXPR -> EXPR [294:16]
+    |       |   |   `--LAND -> && [294:16]
+    |       |   |       |--LAND -> && [293:43]
+    |       |   |       |   |--LNOT -> ! [293:12]
+    |       |   |       |   |   `--METHOD_CALL -> ( [293:36]
+    |       |   |       |   |       |--DOT -> . [293:24]
+    |       |   |       |   |       |   |--IDENT -> failedTests [293:13]
+    |       |   |       |   |       |   `--IDENT -> containsKey [293:25]
+    |       |   |       |   |       |--ELIST -> ELIST [293:37]
+    |       |   |       |   |       |   `--EXPR -> EXPR [293:37]
+    |       |   |       |   |       |       `--IDENT -> test [293:37]
+    |       |   |       |   |       `--RPAREN -> ) [293:41]
+    |       |   |       |   `--LNOT -> ! [293:46]
+    |       |   |       |       `--METHOD_CALL -> ( [293:71]
+    |       |   |       |           |--DOT -> . [293:59]
+    |       |   |       |           |   |--IDENT -> skippedTests [293:47]
+    |       |   |       |           |   `--IDENT -> containsKey [293:60]
+    |       |   |       |           |--ELIST -> ELIST [293:72]
+    |       |   |       |           |   `--EXPR -> EXPR [293:72]
+    |       |   |       |           |       `--IDENT -> testDescription [293:72]
+    |       |   |       |           `--RPAREN -> ) [293:87]
+    |       |   |       `--LNOT -> ! [294:19]
+    |       |   |           `--METHOD_CALL -> ( [294:44]
+    |       |   |               |--DOT -> . [294:32]
+    |       |   |               |   |--IDENT -> ignoredTests [294:20]
+    |       |   |               |   `--IDENT -> containsKey [294:33]
+    |       |   |               |--ELIST -> ELIST [294:45]
+    |       |   |               |   `--EXPR -> EXPR [294:45]
+    |       |   |               |       `--IDENT -> testDescription [294:45]
+    |       |   |               `--RPAREN -> ) [294:60]
+    |       |   |--RPAREN -> ) [294:61]
+    |       |   |--SLIST -> { [294:63]
+    |       |   |   |--EXPR -> EXPR [295:24]
+    |       |   |   |   `--ASSIGN -> = [295:24]
+    |       |   |   |       |--IDENT -> currentTest [295:12]
+    |       |   |   |       `--METHOD_CALL -> ( [295:43]
+    |       |   |   |           |--DOT -> . [295:29]
+    |       |   |   |           |   |--IDENT -> doc [295:26]
+    |       |   |   |           |   `--IDENT -> createElement [295:30]
+    |       |   |   |           |--ELIST -> ELIST [295:44]
+    |       |   |   |           |   `--EXPR -> EXPR [295:44]
+    |       |   |   |           |       `--STRING_LITERAL -> "TESTCASE" [295:44]
+    |       |   |   |           `--RPAREN -> ) [295:54]
+    |       |   |   |--SEMI -> ; [295:55]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [296:12]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [296:12]
+    |       |   |   |   |--TYPE -> TYPE [296:12]
+    |       |   |   |   |   `--IDENT -> String [296:12]
+    |       |   |   |   |--IDENT -> n [296:19]
+    |       |   |   |   `--ASSIGN -> = [296:21]
+    |       |   |   |       `--EXPR -> EXPR [296:23]
+    |       |   |   |           `--STRING_LITERAL -> "" [296:23]
+    |       |   |   |--SEMI -> ; [296:25]
+    |       |   |   |--LITERAL_IF -> if [297:12]
+    |       |   |   |   |--LPAREN -> ( [297:15]
+    |       |   |   |   |--EXPR -> EXPR [297:26]
+    |       |   |   |   |   `--LAND -> && [297:26]
+    |       |   |   |   |       |--NOT_EQUAL -> != [297:18]
+    |       |   |   |   |       |   |--IDENT -> n [297:16]
+    |       |   |   |   |       |   `--LITERAL_NULL -> null [297:21]
+    |       |   |   |   |       `--LNOT -> ! [297:29]
+    |       |   |   |   |           `--METHOD_CALL -> ( [297:41]
+    |       |   |   |   |               |--DOT -> . [297:33]
+    |       |   |   |   |               |   |--IDENT -> tag [297:30]
+    |       |   |   |   |               |   `--IDENT -> isEmpty [297:34]
+    |       |   |   |   |               |--ELIST -> ELIST [297:42]
+    |       |   |   |   |               `--RPAREN -> ) [297:42]
+    |       |   |   |   |--RPAREN -> ) [297:43]
+    |       |   |   |   |--EXPR -> EXPR [298:18]
+    |       |   |   |   |   `--ASSIGN -> = [298:18]
+    |       |   |   |   |       |--IDENT -> n [298:16]
+    |       |   |   |   |       `--PLUS -> + [298:28]
+    |       |   |   |   |           |--PLUS -> + [298:22]
+    |       |   |   |   |           |   |--IDENT -> n [298:20]
+    |       |   |   |   |           |   `--STRING_LITERAL -> "-" [298:24]
+    |       |   |   |   |           `--IDENT -> tag [298:30]
+    |       |   |   |   `--SEMI -> ; [298:33]
+    |       |   |   |--EXPR -> EXPR [299:36]
+    |       |   |   |   `--METHOD_CALL -> ( [299:36]
+    |       |   |   |       |--DOT -> . [299:23]
+    |       |   |   |       |   |--IDENT -> currentTest [299:12]
+    |       |   |   |       |   `--IDENT -> setAttribute [299:24]
+    |       |   |   |       |--ELIST -> ELIST [299:37]
+    |       |   |   |       |   |--EXPR -> EXPR [299:37]
+    |       |   |   |       |   |   `--IDENT -> ATTR_NAME [299:37]
+    |       |   |   |       |   |--COMMA -> , [299:46]
+    |       |   |   |       |   `--EXPR -> EXPR [300:47]
+    |       |   |   |       |       `--QUESTION -> ? [300:47]
+    |       |   |   |       |           |--EQUAL -> == [300:39]
+    |       |   |   |       |           |   |--IDENT -> n [300:37]
+    |       |   |   |       |           |   `--LITERAL_NULL -> null [300:42]
+    |       |   |   |       |           |--IDENT -> UNKNOWN [300:49]
+    |       |   |   |       |           |--COLON -> : [300:57]
+    |       |   |   |       |           `--IDENT -> n [300:59]
+    |       |   |   |       `--RPAREN -> ) [300:60]
+    |       |   |   |--SEMI -> ; [300:61]
+    |       |   |   |--EXPR -> EXPR [303:36]
+    |       |   |   |   `--METHOD_CALL -> ( [303:36]
+    |       |   |   |       |--DOT -> . [303:23]
+    |       |   |   |       |   |--SINGLE_LINE_COMMENT -> // [301:12]
+    |       |   |   |       |   |   `--COMMENT_CONTENT ->  a TestSuite can contain Tests from multiple classes,\n [301:14]
+    |       |   |   |       |   |--SINGLE_LINE_COMMENT -> // [302:12]
+    |       |   |   |       |   |   `--COMMENT_CONTENT ->  even tests with the same name - disambiguate them.\n [302:14]
+    |       |   |   |       |   |--IDENT -> currentTest [303:12]
+    |       |   |   |       |   `--IDENT -> setAttribute [303:24]
+    |       |   |   |       |--ELIST -> ELIST [303:37]
+    |       |   |   |       |   |--EXPR -> EXPR [303:37]
+    |       |   |   |       |   |   `--STRING_LITERAL -> "ATTR_CLASSNAME" [303:37]
+    |       |   |   |       |   |--COMMA -> , [303:53]
+    |       |   |   |       |   `--EXPR -> EXPR [304:20]
+    |       |   |   |       |       `--STRING_LITERAL -> "" [304:20]
+    |       |   |   |       `--RPAREN -> ) [304:22]
+    |       |   |   |--SEMI -> ; [304:23]
+    |       |   |   |--EXPR -> EXPR [305:35]
+    |       |   |   |   `--METHOD_CALL -> ( [305:35]
+    |       |   |   |       |--DOT -> . [305:23]
+    |       |   |   |       |   |--IDENT -> rootElement [305:12]
+    |       |   |   |       |   `--IDENT -> appendChild [305:24]
+    |       |   |   |       |--ELIST -> ELIST [305:36]
+    |       |   |   |       |   `--EXPR -> EXPR [305:36]
+    |       |   |   |       |       `--IDENT -> currentTest [305:36]
+    |       |   |   |       `--RPAREN -> ) [305:47]
+    |       |   |   |--SEMI -> ; [305:48]
+    |       |   |   |--EXPR -> EXPR [306:28]
+    |       |   |   |   `--METHOD_CALL -> ( [306:28]
+    |       |   |   |       |--DOT -> . [306:24]
+    |       |   |   |       |   |--IDENT -> testElements [306:12]
+    |       |   |   |       |   `--IDENT -> put [306:25]
+    |       |   |   |       |--ELIST -> ELIST [306:46]
+    |       |   |   |       |   |--EXPR -> EXPR [306:46]
+    |       |   |   |       |   |   `--METHOD_CALL -> ( [306:46]
+    |       |   |   |       |   |       |--IDENT -> createDescription [306:29]
+    |       |   |   |       |   |       |--ELIST -> ELIST [306:47]
+    |       |   |   |       |   |       |   `--EXPR -> EXPR [306:47]
+    |       |   |   |       |   |       |       `--IDENT -> test [306:47]
+    |       |   |   |       |   |       `--RPAREN -> ) [306:51]
+    |       |   |   |       |   |--COMMA -> , [306:52]
+    |       |   |   |       |   `--EXPR -> EXPR [306:54]
+    |       |   |   |       |       `--IDENT -> currentTest [306:54]
+    |       |   |   |       `--RPAREN -> ) [306:65]
+    |       |   |   |--SEMI -> ; [306:66]
+    |       |   |   `--RCURLY -> } [307:8]
+    |       |   `--LITERAL_ELSE -> else [307:10]
+    |       |       `--SLIST -> { [307:15]
+    |       |           |--EXPR -> EXPR [308:24]
+    |       |           |   `--ASSIGN -> = [308:24]
+    |       |           |       |--IDENT -> currentTest [308:12]
+    |       |           |       `--METHOD_CALL -> ( [308:42]
+    |       |           |           |--DOT -> . [308:38]
+    |       |           |           |   |--IDENT -> testElements [308:26]
+    |       |           |           |   `--IDENT -> get [308:39]
+    |       |           |           |--ELIST -> ELIST [308:43]
+    |       |           |           |   `--EXPR -> EXPR [308:43]
+    |       |           |           |       `--IDENT -> testDescription [308:43]
+    |       |           |           `--RPAREN -> ) [308:58]
+    |       |           |--SEMI -> ; [308:59]
+    |       |           `--RCURLY -> } [309:8]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [311:8]
+    |       |   |--MODIFIERS -> MODIFIERS [311:8]
+    |       |   |   `--FINAL -> final [311:8]
+    |       |   |--TYPE -> TYPE [311:14]
+    |       |   |   `--IDENT -> Long [311:14]
+    |       |   |--IDENT -> l [311:19]
+    |       |   `--ASSIGN -> = [311:21]
+    |       |       `--EXPR -> EXPR [311:37]
+    |       |           `--METHOD_CALL -> ( [311:37]
+    |       |               |--DOT -> . [311:33]
+    |       |               |   |--IDENT -> testStarts [311:23]
+    |       |               |   `--IDENT -> get [311:34]
+    |       |               |--ELIST -> ELIST [311:55]
+    |       |               |   `--EXPR -> EXPR [311:55]
+    |       |               |       `--METHOD_CALL -> ( [311:55]
+    |       |               |           |--IDENT -> createDescription [311:38]
+    |       |               |           |--ELIST -> ELIST [311:56]
+    |       |               |           |   `--EXPR -> EXPR [311:56]
+    |       |               |           |       `--IDENT -> test [311:56]
+    |       |               |           `--RPAREN -> ) [311:60]
+    |       |               `--RPAREN -> ) [311:61]
+    |       |--SEMI -> ; [311:62]
+    |       `--RCURLY -> } [312:4]
+    |--METHOD_DEF -> METHOD_DEF [321:4]
+    |   |--MODIFIERS -> MODIFIERS [321:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [314:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * Interface TestListener for JUnit &lt;= 3.4.\n     *\n     * <p>A Test failed.\n     * @param test the test.\n     * @param t the exception.\n      [314:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [320:5]
+    |   |   `--LITERAL_PUBLIC -> public [321:4]
+    |   |--TYPE -> TYPE [321:11]
+    |   |   `--LITERAL_VOID -> void [321:11]
+    |   |--IDENT -> addFailure [321:16]
+    |   |--LPAREN -> ( [321:26]
+    |   |--PARAMETERS -> PARAMETERS [321:27]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [321:27]
+    |   |   |   |--MODIFIERS -> MODIFIERS [321:27]
+    |   |   |   |   `--FINAL -> final [321:27]
+    |   |   |   |--TYPE -> TYPE [321:33]
+    |   |   |   |   `--IDENT -> Test [321:33]
+    |   |   |   `--IDENT -> test [321:38]
+    |   |   |--COMMA -> , [321:42]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [321:44]
+    |   |       |--MODIFIERS -> MODIFIERS [321:44]
+    |   |       |   `--FINAL -> final [321:44]
+    |   |       |--TYPE -> TYPE [321:50]
+    |   |       |   `--IDENT -> Throwable [321:50]
+    |   |       `--IDENT -> t [321:60]
+    |   |--RPAREN -> ) [321:61]
+    |   `--SLIST -> { [321:63]
+    |       |--EXPR -> EXPR [322:19]
+    |       |   `--METHOD_CALL -> ( [322:19]
+    |       |       |--IDENT -> formatError [322:8]
+    |       |       |--ELIST -> ELIST [322:20]
+    |       |       |   |--EXPR -> EXPR [322:20]
+    |       |       |   |   `--STRING_LITERAL -> "FAILURE" [322:20]
+    |       |       |   |--COMMA -> , [322:29]
+    |       |       |   |--EXPR -> EXPR [322:31]
+    |       |       |   |   `--IDENT -> test [322:31]
+    |       |       |   |--COMMA -> , [322:35]
+    |       |       |   `--EXPR -> EXPR [322:37]
+    |       |       |       `--IDENT -> t [322:37]
+    |       |       `--RPAREN -> ) [322:38]
+    |       |--SEMI -> ; [322:39]
+    |       `--RCURLY -> } [323:4]
+    |--METHOD_DEF -> METHOD_DEF [332:4]
+    |   |--MODIFIERS -> MODIFIERS [332:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [325:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * Interface TestListener for JUnit &gt; 3.4.\n     *\n     * <p>A Test failed.\n     * @param test the test.\n     * @param t the assertion.\n      [325:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [331:5]
+    |   |   `--LITERAL_PUBLIC -> public [332:4]
+    |   |--TYPE -> TYPE [332:11]
+    |   |   `--LITERAL_VOID -> void [332:11]
+    |   |--IDENT -> addFailure [332:16]
+    |   |--LPAREN -> ( [332:26]
+    |   |--PARAMETERS -> PARAMETERS [332:27]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [332:27]
+    |   |   |   |--MODIFIERS -> MODIFIERS [332:27]
+    |   |   |   |   `--FINAL -> final [332:27]
+    |   |   |   |--TYPE -> TYPE [332:33]
+    |   |   |   |   `--IDENT -> Test [332:33]
+    |   |   |   `--IDENT -> test [332:38]
+    |   |   |--COMMA -> , [332:42]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [332:44]
+    |   |       |--MODIFIERS -> MODIFIERS [332:44]
+    |   |       |   `--FINAL -> final [332:44]
+    |   |       |--TYPE -> TYPE [332:50]
+    |   |       |   `--IDENT -> AssertionFailedError [332:50]
+    |   |       `--IDENT -> t [332:71]
+    |   |--RPAREN -> ) [332:72]
+    |   `--SLIST -> { [332:74]
+    |       |--EXPR -> EXPR [333:18]
+    |       |   `--METHOD_CALL -> ( [333:18]
+    |       |       |--IDENT -> addFailure [333:8]
+    |       |       |--ELIST -> ELIST [333:19]
+    |       |       |   |--EXPR -> EXPR [333:19]
+    |       |       |   |   `--IDENT -> test [333:19]
+    |       |       |   |--COMMA -> , [333:23]
+    |       |       |   `--EXPR -> EXPR [333:25]
+    |       |       |       `--TYPECAST -> ( [333:25]
+    |       |       |           |--TYPE -> TYPE [333:26]
+    |       |       |           |   `--IDENT -> Throwable [333:26]
+    |       |       |           |--RPAREN -> ) [333:35]
+    |       |       |           `--IDENT -> t [333:37]
+    |       |       `--RPAREN -> ) [333:38]
+    |       |--SEMI -> ; [333:39]
+    |       `--RCURLY -> } [334:4]
+    |--METHOD_DEF -> METHOD_DEF [343:4]
+    |   |--MODIFIERS -> MODIFIERS [343:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [336:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * Interface TestListener.\n     *\n     * <p>An error occurred while running the test.\n     * @param test the test.\n     * @param t the error.\n      [336:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [342:5]
+    |   |   `--LITERAL_PUBLIC -> public [343:4]
+    |   |--TYPE -> TYPE [343:11]
+    |   |   `--LITERAL_VOID -> void [343:11]
+    |   |--IDENT -> addError [343:16]
+    |   |--LPAREN -> ( [343:24]
+    |   |--PARAMETERS -> PARAMETERS [343:25]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [343:25]
+    |   |   |   |--MODIFIERS -> MODIFIERS [343:25]
+    |   |   |   |   `--FINAL -> final [343:25]
+    |   |   |   |--TYPE -> TYPE [343:31]
+    |   |   |   |   `--IDENT -> Test [343:31]
+    |   |   |   `--IDENT -> test [343:36]
+    |   |   |--COMMA -> , [343:40]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [343:42]
+    |   |       |--MODIFIERS -> MODIFIERS [343:42]
+    |   |       |   `--FINAL -> final [343:42]
+    |   |       |--TYPE -> TYPE [343:48]
+    |   |       |   `--IDENT -> Throwable [343:48]
+    |   |       `--IDENT -> t [343:58]
+    |   |--RPAREN -> ) [343:59]
+    |   `--SLIST -> { [343:61]
+    |       |--EXPR -> EXPR [344:19]
+    |       |   `--METHOD_CALL -> ( [344:19]
+    |       |       |--IDENT -> formatError [344:8]
+    |       |       |--ELIST -> ELIST [344:20]
+    |       |       |   |--EXPR -> EXPR [344:20]
+    |       |       |   |   `--STRING_LITERAL -> "ERROR" [344:20]
+    |       |       |   |--COMMA -> , [344:27]
+    |       |       |   |--EXPR -> EXPR [344:29]
+    |       |       |   |   `--IDENT -> test [344:29]
+    |       |       |   |--COMMA -> , [344:33]
+    |       |       |   `--EXPR -> EXPR [344:35]
+    |       |       |       `--IDENT -> t [344:35]
+    |       |       `--RPAREN -> ) [344:36]
+    |       |--SEMI -> ; [344:37]
+    |       `--RCURLY -> } [345:4]
+    |--METHOD_DEF -> METHOD_DEF [347:4]
+    |   |--MODIFIERS -> MODIFIERS [347:4]
+    |   |   `--LITERAL_PRIVATE -> private [347:4]
+    |   |--TYPE -> TYPE [347:12]
+    |   |   `--LITERAL_VOID -> void [347:12]
+    |   |--IDENT -> formatError [347:17]
+    |   |--LPAREN -> ( [347:28]
+    |   |--PARAMETERS -> PARAMETERS [347:29]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [347:29]
+    |   |   |   |--MODIFIERS -> MODIFIERS [347:29]
+    |   |   |   |   `--FINAL -> final [347:29]
+    |   |   |   |--TYPE -> TYPE [347:35]
+    |   |   |   |   `--IDENT -> String [347:35]
+    |   |   |   `--IDENT -> type [347:42]
+    |   |   |--COMMA -> , [347:46]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [347:48]
+    |   |   |   |--MODIFIERS -> MODIFIERS [347:48]
+    |   |   |   |   `--FINAL -> final [347:48]
+    |   |   |   |--TYPE -> TYPE [347:54]
+    |   |   |   |   `--IDENT -> Test [347:54]
+    |   |   |   `--IDENT -> test [347:59]
+    |   |   |--COMMA -> , [347:63]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [347:65]
+    |   |       |--MODIFIERS -> MODIFIERS [347:65]
+    |   |       |   `--FINAL -> final [347:65]
+    |   |       |--TYPE -> TYPE [347:71]
+    |   |       |   `--IDENT -> Throwable [347:71]
+    |   |       `--IDENT -> t [347:81]
+    |   |--RPAREN -> ) [347:82]
+    |   `--SLIST -> { [347:84]
+    |       |--LITERAL_IF -> if [348:8]
+    |       |   |--LPAREN -> ( [348:11]
+    |       |   |--EXPR -> EXPR [348:17]
+    |       |   |   `--NOT_EQUAL -> != [348:17]
+    |       |   |       |--IDENT -> test [348:12]
+    |       |   |       `--LITERAL_NULL -> null [348:20]
+    |       |   |--RPAREN -> ) [348:24]
+    |       |   `--SLIST -> { [348:26]
+    |       |       |--EXPR -> EXPR [349:19]
+    |       |       |   `--METHOD_CALL -> ( [349:19]
+    |       |       |       |--IDENT -> endTest [349:12]
+    |       |       |       |--ELIST -> ELIST [349:20]
+    |       |       |       |   `--EXPR -> EXPR [349:20]
+    |       |       |       |       `--IDENT -> test [349:20]
+    |       |       |       `--RPAREN -> ) [349:24]
+    |       |       |--SEMI -> ; [349:25]
+    |       |       |--EXPR -> EXPR [350:27]
+    |       |       |   `--METHOD_CALL -> ( [350:27]
+    |       |       |       |--DOT -> . [350:23]
+    |       |       |       |   |--IDENT -> failedTests [350:12]
+    |       |       |       |   `--IDENT -> put [350:24]
+    |       |       |       |--ELIST -> ELIST [350:28]
+    |       |       |       |   |--EXPR -> EXPR [350:28]
+    |       |       |       |   |   `--IDENT -> test [350:28]
+    |       |       |       |   |--COMMA -> , [350:32]
+    |       |       |       |   `--EXPR -> EXPR [350:34]
+    |       |       |       |       `--IDENT -> test [350:34]
+    |       |       |       `--RPAREN -> ) [350:38]
+    |       |       |--SEMI -> ; [350:39]
+    |       |       `--RCURLY -> } [351:8]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [353:8]
+    |       |   |--MODIFIERS -> MODIFIERS [353:8]
+    |       |   |   `--FINAL -> final [353:8]
+    |       |   |--TYPE -> TYPE [353:14]
+    |       |   |   `--IDENT -> Element [353:14]
+    |       |   |--IDENT -> nested [353:22]
+    |       |   `--ASSIGN -> = [353:29]
+    |       |       `--EXPR -> EXPR [353:48]
+    |       |           `--METHOD_CALL -> ( [353:48]
+    |       |               |--DOT -> . [353:34]
+    |       |               |   |--IDENT -> doc [353:31]
+    |       |               |   `--IDENT -> createElement [353:35]
+    |       |               |--ELIST -> ELIST [353:49]
+    |       |               |   `--EXPR -> EXPR [353:49]
+    |       |               |       `--IDENT -> type [353:49]
+    |       |               `--RPAREN -> ) [353:53]
+    |       |--SEMI -> ; [353:54]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [354:8]
+    |       |   |--MODIFIERS -> MODIFIERS [354:8]
+    |       |   |--TYPE -> TYPE [354:8]
+    |       |   |   `--IDENT -> Element [354:8]
+    |       |   `--IDENT -> currentTest [354:16]
+    |       |--SEMI -> ; [354:27]
+    |       |--LITERAL_IF -> if [355:8]
+    |       |   |--LPAREN -> ( [355:11]
+    |       |   |--EXPR -> EXPR [355:17]
+    |       |   |   `--NOT_EQUAL -> != [355:17]
+    |       |   |       |--IDENT -> test [355:12]
+    |       |   |       `--LITERAL_NULL -> null [355:20]
+    |       |   |--RPAREN -> ) [355:24]
+    |       |   |--SLIST -> { [355:26]
+    |       |   |   |--EXPR -> EXPR [356:24]
+    |       |   |   |   `--ASSIGN -> = [356:24]
+    |       |   |   |       |--IDENT -> currentTest [356:12]
+    |       |   |   |       `--METHOD_CALL -> ( [356:42]
+    |       |   |   |           |--DOT -> . [356:38]
+    |       |   |   |           |   |--IDENT -> testElements [356:26]
+    |       |   |   |           |   `--IDENT -> get [356:39]
+    |       |   |   |           |--ELIST -> ELIST [356:60]
+    |       |   |   |           |   `--EXPR -> EXPR [356:60]
+    |       |   |   |           |       `--METHOD_CALL -> ( [356:60]
+    |       |   |   |           |           |--IDENT -> createDescription [356:43]
+    |       |   |   |           |           |--ELIST -> ELIST [356:61]
+    |       |   |   |           |           |   `--EXPR -> EXPR [356:61]
+    |       |   |   |           |           |       `--IDENT -> test [356:61]
+    |       |   |   |           |           `--RPAREN -> ) [356:65]
+    |       |   |   |           `--RPAREN -> ) [356:66]
+    |       |   |   |--SEMI -> ; [356:67]
+    |       |   |   `--RCURLY -> } [357:8]
+    |       |   `--LITERAL_ELSE -> else [357:10]
+    |       |       `--SLIST -> { [357:15]
+    |       |           |--EXPR -> EXPR [358:24]
+    |       |           |   `--ASSIGN -> = [358:24]
+    |       |           |       |--IDENT -> currentTest [358:12]
+    |       |           |       `--IDENT -> rootElement [358:26]
+    |       |           |--SEMI -> ; [358:37]
+    |       |           `--RCURLY -> } [359:8]
+    |       |--EXPR -> EXPR [361:31]
+    |       |   `--METHOD_CALL -> ( [361:31]
+    |       |       |--DOT -> . [361:19]
+    |       |       |   |--IDENT -> currentTest [361:8]
+    |       |       |   `--IDENT -> appendChild [361:20]
+    |       |       |--ELIST -> ELIST [361:32]
+    |       |       |   `--EXPR -> EXPR [361:32]
+    |       |       |       `--IDENT -> nested [361:32]
+    |       |       `--RPAREN -> ) [361:38]
+    |       |--SEMI -> ; [361:39]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [363:8]
+    |       |   |--MODIFIERS -> MODIFIERS [363:8]
+    |       |   |   `--FINAL -> final [363:8]
+    |       |   |--TYPE -> TYPE [363:14]
+    |       |   |   `--IDENT -> String [363:14]
+    |       |   |--IDENT -> message [363:21]
+    |       |   `--ASSIGN -> = [363:29]
+    |       |       `--EXPR -> EXPR [363:43]
+    |       |           `--METHOD_CALL -> ( [363:43]
+    |       |               |--DOT -> . [363:32]
+    |       |               |   |--IDENT -> t [363:31]
+    |       |               |   `--IDENT -> getMessage [363:33]
+    |       |               |--ELIST -> ELIST [363:44]
+    |       |               `--RPAREN -> ) [363:44]
+    |       |--SEMI -> ; [363:45]
+    |       |--LITERAL_IF -> if [364:8]
+    |       |   |--LPAREN -> ( [364:11]
+    |       |   |--EXPR -> EXPR [364:28]
+    |       |   |   `--LAND -> && [364:28]
+    |       |   |       |--NOT_EQUAL -> != [364:20]
+    |       |   |       |   |--IDENT -> message [364:12]
+    |       |   |       |   `--LITERAL_NULL -> null [364:23]
+    |       |   |       `--GT -> > [364:48]
+    |       |   |           |--METHOD_CALL -> ( [364:45]
+    |       |   |           |   |--DOT -> . [364:38]
+    |       |   |           |   |   |--IDENT -> message [364:31]
+    |       |   |           |   |   `--IDENT -> length [364:39]
+    |       |   |           |   |--ELIST -> ELIST [364:46]
+    |       |   |           |   `--RPAREN -> ) [364:46]
+    |       |   |           `--NUM_INT -> 0 [364:50]
+    |       |   |--RPAREN -> ) [364:51]
+    |       |   `--SLIST -> { [364:53]
+    |       |       |--EXPR -> EXPR [365:31]
+    |       |       |   `--METHOD_CALL -> ( [365:31]
+    |       |       |       |--DOT -> . [365:18]
+    |       |       |       |   |--IDENT -> nested [365:12]
+    |       |       |       |   `--IDENT -> setAttribute [365:19]
+    |       |       |       |--ELIST -> ELIST [365:32]
+    |       |       |       |   |--EXPR -> EXPR [365:32]
+    |       |       |       |   |   `--STRING_LITERAL -> "ATTR_MESSAGE" [365:32]
+    |       |       |       |   |--COMMA -> , [365:46]
+    |       |       |       |   `--EXPR -> EXPR [365:60]
+    |       |       |       |       `--METHOD_CALL -> ( [365:60]
+    |       |       |       |           |--DOT -> . [365:49]
+    |       |       |       |           |   |--IDENT -> t [365:48]
+    |       |       |       |           |   `--IDENT -> getMessage [365:50]
+    |       |       |       |           |--ELIST -> ELIST [365:61]
+    |       |       |       |           `--RPAREN -> ) [365:61]
+    |       |       |       `--RPAREN -> ) [365:62]
+    |       |       |--SEMI -> ; [365:63]
+    |       |       `--RCURLY -> } [366:8]
+    |       |--EXPR -> EXPR [367:27]
+    |       |   `--METHOD_CALL -> ( [367:27]
+    |       |       |--DOT -> . [367:14]
+    |       |       |   |--IDENT -> nested [367:8]
+    |       |       |   `--IDENT -> setAttribute [367:15]
+    |       |       |--ELIST -> ELIST [367:28]
+    |       |       |   |--EXPR -> EXPR [367:28]
+    |       |       |   |   `--STRING_LITERAL -> "ATTR_TYPE" [367:28]
+    |       |       |   |--COMMA -> , [367:39]
+    |       |       |   `--EXPR -> EXPR [367:61]
+    |       |       |       `--METHOD_CALL -> ( [367:61]
+    |       |       |           |--DOT -> . [367:53]
+    |       |       |           |   |--METHOD_CALL -> ( [367:51]
+    |       |       |           |   |   |--DOT -> . [367:42]
+    |       |       |           |   |   |   |--IDENT -> t [367:41]
+    |       |       |           |   |   |   `--IDENT -> getClass [367:43]
+    |       |       |           |   |   |--ELIST -> ELIST [367:52]
+    |       |       |           |   |   `--RPAREN -> ) [367:52]
+    |       |       |           |   `--IDENT -> getName [367:54]
+    |       |       |           |--ELIST -> ELIST [367:62]
+    |       |       |           `--RPAREN -> ) [367:62]
+    |       |       `--RPAREN -> ) [367:63]
+    |       |--SEMI -> ; [367:64]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [369:8]
+    |       |   |--MODIFIERS -> MODIFIERS [369:8]
+    |       |   |   `--FINAL -> final [369:8]
+    |       |   |--TYPE -> TYPE [369:14]
+    |       |   |   `--IDENT -> String [369:14]
+    |       |   |--IDENT -> strace [369:21]
+    |       |   `--ASSIGN -> = [369:28]
+    |       |       `--EXPR -> EXPR [369:30]
+    |       |           `--STRING_LITERAL -> "JUnitTestRunner.getFilteredTrace(t" [369:30]
+    |       |--SEMI -> ; [369:66]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [370:8]
+    |       |   |--MODIFIERS -> MODIFIERS [370:8]
+    |       |   |   `--FINAL -> final [370:8]
+    |       |   |--TYPE -> TYPE [370:14]
+    |       |   |   `--IDENT -> Text [370:14]
+    |       |   |--IDENT -> trace [370:19]
+    |       |   `--ASSIGN -> = [370:25]
+    |       |       `--EXPR -> EXPR [370:45]
+    |       |           `--METHOD_CALL -> ( [370:45]
+    |       |               |--DOT -> . [370:30]
+    |       |               |   |--IDENT -> doc [370:27]
+    |       |               |   `--IDENT -> createTextNode [370:31]
+    |       |               |--ELIST -> ELIST [370:46]
+    |       |               |   `--EXPR -> EXPR [370:46]
+    |       |               |       `--IDENT -> strace [370:46]
+    |       |               `--RPAREN -> ) [370:52]
+    |       |--SEMI -> ; [370:53]
+    |       |--EXPR -> EXPR [371:26]
+    |       |   `--METHOD_CALL -> ( [371:26]
+    |       |       |--DOT -> . [371:14]
+    |       |       |   |--IDENT -> nested [371:8]
+    |       |       |   `--IDENT -> appendChild [371:15]
+    |       |       |--ELIST -> ELIST [371:27]
+    |       |       |   `--EXPR -> EXPR [371:27]
+    |       |       |       `--IDENT -> trace [371:27]
+    |       |       `--RPAREN -> ) [371:32]
+    |       |--SEMI -> ; [371:33]
+    |       `--RCURLY -> } [372:4]
+    |--METHOD_DEF -> METHOD_DEF [374:4]
+    |   |--MODIFIERS -> MODIFIERS [374:4]
+    |   |   `--LITERAL_PRIVATE -> private [374:4]
+    |   |--TYPE -> TYPE [374:12]
+    |   |   `--LITERAL_VOID -> void [374:12]
+    |   |--IDENT -> formatOutput [374:17]
+    |   |--LPAREN -> ( [374:29]
+    |   |--PARAMETERS -> PARAMETERS [374:30]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [374:30]
+    |   |   |   |--MODIFIERS -> MODIFIERS [374:30]
+    |   |   |   |   `--FINAL -> final [374:30]
+    |   |   |   |--TYPE -> TYPE [374:36]
+    |   |   |   |   `--IDENT -> String [374:36]
+    |   |   |   `--IDENT -> type [374:43]
+    |   |   |--COMMA -> , [374:47]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [374:49]
+    |   |       |--MODIFIERS -> MODIFIERS [374:49]
+    |   |       |   `--FINAL -> final [374:49]
+    |   |       |--TYPE -> TYPE [374:55]
+    |   |       |   `--IDENT -> String [374:55]
+    |   |       `--IDENT -> output [374:62]
+    |   |--RPAREN -> ) [374:68]
+    |   `--SLIST -> { [374:70]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [375:8]
+    |       |   |--MODIFIERS -> MODIFIERS [375:8]
+    |       |   |   `--FINAL -> final [375:8]
+    |       |   |--TYPE -> TYPE [375:14]
+    |       |   |   `--IDENT -> Element [375:14]
+    |       |   |--IDENT -> nested [375:22]
+    |       |   `--ASSIGN -> = [375:29]
+    |       |       `--EXPR -> EXPR [375:48]
+    |       |           `--METHOD_CALL -> ( [375:48]
+    |       |               |--DOT -> . [375:34]
+    |       |               |   |--IDENT -> doc [375:31]
+    |       |               |   `--IDENT -> createElement [375:35]
+    |       |               |--ELIST -> ELIST [375:49]
+    |       |               |   `--EXPR -> EXPR [375:49]
+    |       |               |       `--IDENT -> type [375:49]
+    |       |               `--RPAREN -> ) [375:53]
+    |       |--SEMI -> ; [375:54]
+    |       |--EXPR -> EXPR [376:31]
+    |       |   `--METHOD_CALL -> ( [376:31]
+    |       |       |--DOT -> . [376:19]
+    |       |       |   |--IDENT -> rootElement [376:8]
+    |       |       |   `--IDENT -> appendChild [376:20]
+    |       |       |--ELIST -> ELIST [376:32]
+    |       |       |   `--EXPR -> EXPR [376:32]
+    |       |       |       `--IDENT -> nested [376:32]
+    |       |       `--RPAREN -> ) [376:38]
+    |       |--SEMI -> ; [376:39]
+    |       |--EXPR -> EXPR [377:26]
+    |       |   `--METHOD_CALL -> ( [377:26]
+    |       |       |--DOT -> . [377:14]
+    |       |       |   |--IDENT -> nested [377:8]
+    |       |       |   `--IDENT -> appendChild [377:15]
+    |       |       |--ELIST -> ELIST [377:49]
+    |       |       |   `--EXPR -> EXPR [377:49]
+    |       |       |       `--METHOD_CALL -> ( [377:49]
+    |       |       |           |--DOT -> . [377:30]
+    |       |       |           |   |--IDENT -> doc [377:27]
+    |       |       |           |   `--IDENT -> createCDATASection [377:31]
+    |       |       |           |--ELIST -> ELIST [377:50]
+    |       |       |           |   `--EXPR -> EXPR [377:50]
+    |       |       |           |       `--IDENT -> output [377:50]
+    |       |       |           `--RPAREN -> ) [377:56]
+    |       |       `--RPAREN -> ) [377:57]
+    |       |--SEMI -> ; [377:58]
+    |       `--RCURLY -> } [378:4]
+    |--METHOD_DEF -> METHOD_DEF [380:4]
+    |   |--MODIFIERS -> MODIFIERS [380:4]
+    |   |   `--LITERAL_PUBLIC -> public [380:4]
+    |   |--TYPE -> TYPE [380:11]
+    |   |   `--LITERAL_VOID -> void [380:11]
+    |   |--IDENT -> testIgnored [380:16]
+    |   |--LPAREN -> ( [380:27]
+    |   |--PARAMETERS -> PARAMETERS [380:28]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [380:28]
+    |   |       |--MODIFIERS -> MODIFIERS [380:28]
+    |   |       |   `--FINAL -> final [380:28]
+    |   |       |--TYPE -> TYPE [380:34]
+    |   |       |   `--IDENT -> Test [380:34]
+    |   |       `--IDENT -> test [380:39]
+    |   |--RPAREN -> ) [380:43]
+    |   `--SLIST -> { [380:45]
+    |       |--EXPR -> EXPR [381:18]
+    |       |   `--METHOD_CALL -> ( [381:18]
+    |       |       |--IDENT -> formatSkip [381:8]
+    |       |       |--ELIST -> ELIST [381:19]
+    |       |       |   |--EXPR -> EXPR [381:19]
+    |       |       |   |   `--IDENT -> test [381:19]
+    |       |       |   |--COMMA -> , [381:23]
+    |       |       |   `--EXPR -> EXPR [381:25]
+    |       |       |       `--STRING_LITERAL -> "JUnitVersionHelper.getIgnoreMessage(test)" [381:25]
+    |       |       `--RPAREN -> ) [381:68]
+    |       |--SEMI -> ; [381:69]
+    |       |--LITERAL_IF -> if [382:8]
+    |       |   |--LPAREN -> ( [382:11]
+    |       |   |--EXPR -> EXPR [382:17]
+    |       |   |   `--NOT_EQUAL -> != [382:17]
+    |       |   |       |--IDENT -> test [382:12]
+    |       |   |       `--LITERAL_NULL -> null [382:20]
+    |       |   |--RPAREN -> ) [382:24]
+    |       |   `--SLIST -> { [382:26]
+    |       |       |--EXPR -> EXPR [383:28]
+    |       |       |   `--METHOD_CALL -> ( [383:28]
+    |       |       |       |--DOT -> . [383:24]
+    |       |       |       |   |--IDENT -> ignoredTests [383:12]
+    |       |       |       |   `--IDENT -> put [383:25]
+    |       |       |       |--ELIST -> ELIST [383:46]
+    |       |       |       |   |--EXPR -> EXPR [383:46]
+    |       |       |       |   |   `--METHOD_CALL -> ( [383:46]
+    |       |       |       |   |       |--IDENT -> createDescription [383:29]
+    |       |       |       |   |       |--ELIST -> ELIST [383:47]
+    |       |       |       |   |       |   `--EXPR -> EXPR [383:47]
+    |       |       |       |   |       |       `--IDENT -> test [383:47]
+    |       |       |       |   |       `--RPAREN -> ) [383:51]
+    |       |       |       |   |--COMMA -> , [383:52]
+    |       |       |       |   `--EXPR -> EXPR [383:54]
+    |       |       |       |       `--IDENT -> test [383:54]
+    |       |       |       `--RPAREN -> ) [383:58]
+    |       |       |--SEMI -> ; [383:59]
+    |       |       `--RCURLY -> } [384:8]
+    |       `--RCURLY -> } [385:4]
+    |--METHOD_DEF -> METHOD_DEF [388:4]
+    |   |--MODIFIERS -> MODIFIERS [388:4]
+    |   |   `--LITERAL_PUBLIC -> public [388:4]
+    |   |--TYPE -> TYPE [388:11]
+    |   |   `--LITERAL_VOID -> void [388:11]
+    |   |--IDENT -> formatSkip [388:16]
+    |   |--LPAREN -> ( [388:26]
+    |   |--PARAMETERS -> PARAMETERS [388:27]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [388:27]
+    |   |   |   |--MODIFIERS -> MODIFIERS [388:27]
+    |   |   |   |   `--FINAL -> final [388:27]
+    |   |   |   |--TYPE -> TYPE [388:33]
+    |   |   |   |   `--IDENT -> Test [388:33]
+    |   |   |   `--IDENT -> test [388:38]
+    |   |   |--COMMA -> , [388:42]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [388:44]
+    |   |       |--MODIFIERS -> MODIFIERS [388:44]
+    |   |       |   `--FINAL -> final [388:44]
+    |   |       |--TYPE -> TYPE [388:50]
+    |   |       |   `--IDENT -> String [388:50]
+    |   |       `--IDENT -> message [388:57]
+    |   |--RPAREN -> ) [388:64]
+    |   `--SLIST -> { [388:66]
+    |       |--LITERAL_IF -> if [389:8]
+    |       |   |--LPAREN -> ( [389:11]
+    |       |   |--EXPR -> EXPR [389:17]
+    |       |   |   `--NOT_EQUAL -> != [389:17]
+    |       |   |       |--IDENT -> test [389:12]
+    |       |   |       `--LITERAL_NULL -> null [389:20]
+    |       |   |--RPAREN -> ) [389:24]
+    |       |   `--SLIST -> { [389:26]
+    |       |       |--EXPR -> EXPR [390:19]
+    |       |       |   `--METHOD_CALL -> ( [390:19]
+    |       |       |       |--IDENT -> endTest [390:12]
+    |       |       |       |--ELIST -> ELIST [390:20]
+    |       |       |       |   `--EXPR -> EXPR [390:20]
+    |       |       |       |       `--IDENT -> test [390:20]
+    |       |       |       `--RPAREN -> ) [390:24]
+    |       |       |--SEMI -> ; [390:25]
+    |       |       `--RCURLY -> } [391:8]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [393:8]
+    |       |   |--MODIFIERS -> MODIFIERS [393:8]
+    |       |   |   `--FINAL -> final [393:8]
+    |       |   |--TYPE -> TYPE [393:14]
+    |       |   |   `--IDENT -> Element [393:14]
+    |       |   |--IDENT -> nested [393:22]
+    |       |   `--ASSIGN -> = [393:29]
+    |       |       `--EXPR -> EXPR [393:48]
+    |       |           `--METHOD_CALL -> ( [393:48]
+    |       |               |--DOT -> . [393:34]
+    |       |               |   |--IDENT -> doc [393:31]
+    |       |               |   `--IDENT -> createElement [393:35]
+    |       |               |--ELIST -> ELIST [393:49]
+    |       |               |   `--EXPR -> EXPR [393:49]
+    |       |               |       `--STRING_LITERAL -> "skipped" [393:49]
+    |       |               `--RPAREN -> ) [393:58]
+    |       |--SEMI -> ; [393:59]
+    |       |--LITERAL_IF -> if [395:8]
+    |       |   |--LPAREN -> ( [395:11]
+    |       |   |--EXPR -> EXPR [395:20]
+    |       |   |   `--NOT_EQUAL -> != [395:20]
+    |       |   |       |--IDENT -> message [395:12]
+    |       |   |       `--LITERAL_NULL -> null [395:23]
+    |       |   |--RPAREN -> ) [395:27]
+    |       |   `--SLIST -> { [395:29]
+    |       |       |--EXPR -> EXPR [396:31]
+    |       |       |   `--METHOD_CALL -> ( [396:31]
+    |       |       |       |--DOT -> . [396:18]
+    |       |       |       |   |--IDENT -> nested [396:12]
+    |       |       |       |   `--IDENT -> setAttribute [396:19]
+    |       |       |       |--ELIST -> ELIST [396:32]
+    |       |       |       |   |--EXPR -> EXPR [396:32]
+    |       |       |       |   |   `--STRING_LITERAL -> "message" [396:32]
+    |       |       |       |   |--COMMA -> , [396:41]
+    |       |       |       |   `--EXPR -> EXPR [396:43]
+    |       |       |       |       `--IDENT -> message [396:43]
+    |       |       |       `--RPAREN -> ) [396:50]
+    |       |       |--SEMI -> ; [396:51]
+    |       |       `--RCURLY -> } [397:8]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [399:8]
+    |       |   |--MODIFIERS -> MODIFIERS [399:8]
+    |       |   |--TYPE -> TYPE [399:8]
+    |       |   |   `--IDENT -> Element [399:8]
+    |       |   `--IDENT -> currentTest [399:16]
+    |       |--SEMI -> ; [399:27]
+    |       |--LITERAL_IF -> if [400:8]
+    |       |   |--LPAREN -> ( [400:11]
+    |       |   |--EXPR -> EXPR [400:17]
+    |       |   |   `--NOT_EQUAL -> != [400:17]
+    |       |   |       |--IDENT -> test [400:12]
+    |       |   |       `--LITERAL_NULL -> null [400:20]
+    |       |   |--RPAREN -> ) [400:24]
+    |       |   |--SLIST -> { [400:26]
+    |       |   |   |--EXPR -> EXPR [401:24]
+    |       |   |   |   `--ASSIGN -> = [401:24]
+    |       |   |   |       |--IDENT -> currentTest [401:12]
+    |       |   |   |       `--METHOD_CALL -> ( [401:42]
+    |       |   |   |           |--DOT -> . [401:38]
+    |       |   |   |           |   |--IDENT -> testElements [401:26]
+    |       |   |   |           |   `--IDENT -> get [401:39]
+    |       |   |   |           |--ELIST -> ELIST [401:60]
+    |       |   |   |           |   `--EXPR -> EXPR [401:60]
+    |       |   |   |           |       `--METHOD_CALL -> ( [401:60]
+    |       |   |   |           |           |--IDENT -> createDescription [401:43]
+    |       |   |   |           |           |--ELIST -> ELIST [401:61]
+    |       |   |   |           |           |   `--EXPR -> EXPR [401:61]
+    |       |   |   |           |           |       `--IDENT -> test [401:61]
+    |       |   |   |           |           `--RPAREN -> ) [401:65]
+    |       |   |   |           `--RPAREN -> ) [401:66]
+    |       |   |   |--SEMI -> ; [401:67]
+    |       |   |   `--RCURLY -> } [402:8]
+    |       |   `--LITERAL_ELSE -> else [402:10]
+    |       |       `--SLIST -> { [402:15]
+    |       |           |--EXPR -> EXPR [403:24]
+    |       |           |   `--ASSIGN -> = [403:24]
+    |       |           |       |--IDENT -> currentTest [403:12]
+    |       |           |       `--IDENT -> rootElement [403:26]
+    |       |           |--SEMI -> ; [403:37]
+    |       |           `--RCURLY -> } [404:8]
+    |       |--EXPR -> EXPR [406:31]
+    |       |   `--METHOD_CALL -> ( [406:31]
+    |       |       |--DOT -> . [406:19]
+    |       |       |   |--IDENT -> currentTest [406:8]
+    |       |       |   `--IDENT -> appendChild [406:20]
+    |       |       |--ELIST -> ELIST [406:32]
+    |       |       |   `--EXPR -> EXPR [406:32]
+    |       |       |       `--IDENT -> nested [406:32]
+    |       |       `--RPAREN -> ) [406:38]
+    |       |--SEMI -> ; [406:39]
+    |       `--RCURLY -> } [408:4]
+    |--METHOD_DEF -> METHOD_DEF [410:4]
+    |   |--MODIFIERS -> MODIFIERS [410:4]
+    |   |   `--LITERAL_PUBLIC -> public [410:4]
+    |   |--TYPE -> TYPE [410:11]
+    |   |   `--LITERAL_VOID -> void [410:11]
+    |   |--IDENT -> testAssumptionFailure [410:16]
+    |   |--LPAREN -> ( [410:37]
+    |   |--PARAMETERS -> PARAMETERS [410:38]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [410:38]
+    |   |   |   |--MODIFIERS -> MODIFIERS [410:38]
+    |   |   |   |   `--FINAL -> final [410:38]
+    |   |   |   |--TYPE -> TYPE [410:44]
+    |   |   |   |   `--IDENT -> Test [410:44]
+    |   |   |   `--IDENT -> test [410:49]
+    |   |   |--COMMA -> , [410:53]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [410:55]
+    |   |       |--MODIFIERS -> MODIFIERS [410:55]
+    |   |       |   `--FINAL -> final [410:55]
+    |   |       |--TYPE -> TYPE [410:61]
+    |   |       |   `--IDENT -> Throwable [410:61]
+    |   |       `--IDENT -> failure [410:71]
+    |   |--RPAREN -> ) [410:78]
+    |   `--SLIST -> { [410:80]
+    |       |--EXPR -> EXPR [411:18]
+    |       |   `--METHOD_CALL -> ( [411:18]
+    |       |       |--IDENT -> formatSkip [411:8]
+    |       |       |--ELIST -> ELIST [411:19]
+    |       |       |   |--EXPR -> EXPR [411:19]
+    |       |       |   |   `--IDENT -> test [411:19]
+    |       |       |   |--COMMA -> , [411:23]
+    |       |       |   `--EXPR -> EXPR [411:43]
+    |       |       |       `--METHOD_CALL -> ( [411:43]
+    |       |       |           |--DOT -> . [411:32]
+    |       |       |           |   |--IDENT -> failure [411:25]
+    |       |       |           |   `--IDENT -> getMessage [411:33]
+    |       |       |           |--ELIST -> ELIST [411:44]
+    |       |       |           `--RPAREN -> ) [411:44]
+    |       |       `--RPAREN -> ) [411:45]
+    |       |--SEMI -> ; [411:46]
+    |       |--EXPR -> EXPR [412:24]
+    |       |   `--METHOD_CALL -> ( [412:24]
+    |       |       |--DOT -> . [412:20]
+    |       |       |   |--IDENT -> skippedTests [412:8]
+    |       |       |   `--IDENT -> put [412:21]
+    |       |       |--ELIST -> ELIST [412:42]
+    |       |       |   |--EXPR -> EXPR [412:42]
+    |       |       |   |   `--METHOD_CALL -> ( [412:42]
+    |       |       |   |       |--IDENT -> createDescription [412:25]
+    |       |       |   |       |--ELIST -> ELIST [412:43]
+    |       |       |   |       |   `--EXPR -> EXPR [412:43]
+    |       |       |   |       |       `--IDENT -> test [412:43]
+    |       |       |   |       `--RPAREN -> ) [412:47]
+    |       |       |   |--COMMA -> , [412:48]
+    |       |       |   `--EXPR -> EXPR [412:50]
+    |       |       |       `--IDENT -> test [412:50]
+    |       |       `--RPAREN -> ) [412:54]
+    |       |--SEMI -> ; [412:55]
+    |       `--RCURLY -> } [414:4]
+    |--RCURLY -> } [415:0]
+    `--SINGLE_LINE_COMMENT -> // [415:2]
+        `--COMMENT_CONTENT ->  XMLJUnitResultFormatter, no newline on purpose [415:4]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionCommentsOnAnnotationsAndEnums.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionCommentsOnAnnotationsAndEnums.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionCommentsOnAnnotationsAndEnums.java
@@ -0,0 +1,143 @@
+/*
+ * See the NOTICE file distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import static com.puppycrawl.tools.checkstyle.grammar.antlr4.LifecyclePhase.GENERATE_RESOURCES;
+import static java.lang.String.format;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.platform.commons.logging.Logger;
+
+class Artifact{}
+class ArtifactRepository{}
+class License{}
+class Model{}
+class Organization{}
+class ProcessRemoteResourcesMojo{}
+@interface Component{
+    Class<MavenProjectBuilder> role();
+}
+class LifecyclePhase{
+    public static final Object GENERATE_RESOURCES = null;
+}
+@interface Mojo{
+    String name();
+}
+@interface Parameter{
+    String defaultValue();
+
+    boolean readonly();
+}
+class ResolutionScope{
+    public static final Object RUNTIME = null;
+}
+class InvalidProjectModelException{}
+class MavenProject{}
+class MavenProjectBuilder{}
+class ProjectBuildingException{}
+
+/**
+ * Extends the Maven Remote Resources plugin to fix memory issue found in it, see
+ * <a href="https://jira.xwiki.org/browse/XCOMMONS-1421">XCOMMONS-1421</a>.
+ * <p>
+ * To be removed when <a href="https://issues.apache.org/jira/browse/MRRESOURCES-106">MRRESOURCES-106</a> is fixed on
+ * the Maven side.
+ *
+ * @version $Id: 45afe6a790dc2b72fec66a9f5b0e95e95105bd43 $
+ * @since 9.11.5
+ * @since 10.5RC1
+ */
+@Mojo(name = "")
+public class InputAntlr4AstRegressionCommentsOnAnnotationsAndEnums
+        extends ProcessRemoteResourcesMojo
+{
+    /**
+     * Control what is injected in the "projects" Velocity binding.
+     *
+     * @version $Id: 45afe6a790dc2b72fec66a9f5b0e95e95105bd43 $
+     */
+    public enum ProjectData
+    {
+        /**
+         * "projects" is empty.
+         */
+        NONE,
+
+        /**
+         * "projects" only contains licenses.
+         */
+        LICENSES,
+
+        /**
+         * "projects" contains full MavenProject metadata
+         * (very expensive but standard Maven Resource plugin behavior).
+         */
+        FULL
+    }
+
+    @Parameter(defaultValue = "NONE", readonly = false)
+    protected ProjectData projectsData;
+
+    @Parameter(defaultValue = "${localRepository}", readonly = true)
+    private ArtifactRepository localRepositoryThis;
+
+    @Component(role = MavenProjectBuilder.class)
+    private MavenProjectBuilder mavenProjectBuilderThis;
+
+    /**
+     * List of Remote Repositories used by the resolver.
+     */
+    @Parameter(defaultValue = "${project.remoteArtifactRepositories}", readonly = true)
+    private List<ArtifactRepository> remoteArtifactRepositoriesThis;
+
+    private Logger getLog() {
+        return null;
+    }
+
+    enum InputJavadocVariableTagsEnum
+    {
+        CONSTANT_A, // violation
+
+        /**
+         *
+         */
+        CONSTANT_B,
+
+        CONSTANT_C // violation
+        {
+            /**
+             *
+             */
+            public void someMethod()
+            {
+            }
+
+            public void someOtherMethod()
+            {
+
+            }
+        }
+    }
+
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionCommentsOnAnnotationsAndEnums.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionCommentsOnAnnotationsAndEnums.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionCommentsOnAnnotationsAndEnums.txt
@@ -0,0 +1,473 @@
+BLOCK_COMMENT_BEGIN -> /* [1:0]
+|--COMMENT_CONTENT -> \n * See the NOTICE file distributed with this work for additional\n * information regarding copyright ownership.\n *\n * This is free software; you can redistribute it and/or modify it\n * under the terms of the GNU Lesser General Public License as\n * published by the Free Software Foundation; either version 2.1 of\n * the License, or (at your option) any later version.\n *\n * This software is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public\n * License along with this software; if not, write to the Free\n * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA\n * 02110-1301 USA, or see the FSF site: http://www.fsf.org.\n  [1:2]
+`--BLOCK_COMMENT_END -> */ [19:1]
+PACKAGE_DEF -> package [20:0]
+|--ANNOTATIONS -> ANNOTATIONS [20:47]
+|--DOT -> . [20:47]
+|   |--DOT -> . [20:39]
+|   |   |--DOT -> . [20:28]
+|   |   |   |--DOT -> . [20:22]
+|   |   |   |   |--DOT -> . [20:11]
+|   |   |   |   |   |--IDENT -> com [20:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [20:12]
+|   |   |   |   `--IDENT -> tools [20:23]
+|   |   |   `--IDENT -> checkstyle [20:29]
+|   |   `--IDENT -> grammar [20:40]
+|   `--IDENT -> antlr4 [20:48]
+`--SEMI -> ; [20:54]
+STATIC_IMPORT -> import [22:0]
+|--LITERAL_STATIC -> static [22:7]
+|--DOT -> . [22:75]
+|   |--DOT -> . [22:60]
+|   |   |--DOT -> . [22:53]
+|   |   |   |--DOT -> . [22:45]
+|   |   |   |   |--DOT -> . [22:34]
+|   |   |   |   |   |--DOT -> . [22:28]
+|   |   |   |   |   |   |--DOT -> . [22:17]
+|   |   |   |   |   |   |   |--IDENT -> com [22:14]
+|   |   |   |   |   |   |   `--IDENT -> puppycrawl [22:18]
+|   |   |   |   |   |   `--IDENT -> tools [22:29]
+|   |   |   |   |   `--IDENT -> checkstyle [22:35]
+|   |   |   |   `--IDENT -> grammar [22:46]
+|   |   |   `--IDENT -> antlr4 [22:54]
+|   |   `--IDENT -> LifecyclePhase [22:61]
+|   `--IDENT -> GENERATE_RESOURCES [22:76]
+`--SEMI -> ; [22:94]
+STATIC_IMPORT -> import [23:0]
+|--LITERAL_STATIC -> static [23:7]
+|--DOT -> . [23:30]
+|   |--DOT -> . [23:23]
+|   |   |--DOT -> . [23:18]
+|   |   |   |--IDENT -> java [23:14]
+|   |   |   `--IDENT -> lang [23:19]
+|   |   `--IDENT -> String [23:24]
+|   `--IDENT -> format [23:31]
+`--SEMI -> ; [23:37]
+IMPORT -> import [25:0]
+|--DOT -> . [25:16]
+|   |--DOT -> . [25:11]
+|   |   |--IDENT -> java [25:7]
+|   |   `--IDENT -> util [25:12]
+|   `--IDENT -> ArrayList [25:17]
+`--SEMI -> ; [25:26]
+IMPORT -> import [26:0]
+|--DOT -> . [26:16]
+|   |--DOT -> . [26:11]
+|   |   |--IDENT -> java [26:7]
+|   |   `--IDENT -> util [26:12]
+|   `--IDENT -> Collections [26:17]
+`--SEMI -> ; [26:28]
+IMPORT -> import [27:0]
+|--DOT -> . [27:16]
+|   |--DOT -> . [27:11]
+|   |   |--IDENT -> java [27:7]
+|   |   `--IDENT -> util [27:12]
+|   `--IDENT -> List [27:17]
+`--SEMI -> ; [27:21]
+IMPORT -> import [28:0]
+|--DOT -> . [28:16]
+|   |--DOT -> . [28:11]
+|   |   |--IDENT -> java [28:7]
+|   |   `--IDENT -> util [28:12]
+|   `--IDENT -> Set [28:17]
+`--SEMI -> ; [28:20]
+IMPORT -> import [30:0]
+|--DOT -> . [30:41]
+|   |--DOT -> . [30:33]
+|   |   |--DOT -> . [30:25]
+|   |   |   |--DOT -> . [30:16]
+|   |   |   |   |--DOT -> . [30:10]
+|   |   |   |   |   |--IDENT -> org [30:7]
+|   |   |   |   |   `--IDENT -> junit [30:11]
+|   |   |   |   `--IDENT -> platform [30:17]
+|   |   |   `--IDENT -> commons [30:26]
+|   |   `--IDENT -> logging [30:34]
+|   `--IDENT -> Logger [30:42]
+`--SEMI -> ; [30:48]
+CLASS_DEF -> CLASS_DEF [32:0]
+|--MODIFIERS -> MODIFIERS [32:0]
+|--LITERAL_CLASS -> class [32:0]
+|--IDENT -> Artifact [32:6]
+`--OBJBLOCK -> OBJBLOCK [32:14]
+    |--LCURLY -> { [32:14]
+    `--RCURLY -> } [32:15]
+CLASS_DEF -> CLASS_DEF [33:0]
+|--MODIFIERS -> MODIFIERS [33:0]
+|--LITERAL_CLASS -> class [33:0]
+|--IDENT -> ArtifactRepository [33:6]
+`--OBJBLOCK -> OBJBLOCK [33:24]
+    |--LCURLY -> { [33:24]
+    `--RCURLY -> } [33:25]
+CLASS_DEF -> CLASS_DEF [34:0]
+|--MODIFIERS -> MODIFIERS [34:0]
+|--LITERAL_CLASS -> class [34:0]
+|--IDENT -> License [34:6]
+`--OBJBLOCK -> OBJBLOCK [34:13]
+    |--LCURLY -> { [34:13]
+    `--RCURLY -> } [34:14]
+CLASS_DEF -> CLASS_DEF [35:0]
+|--MODIFIERS -> MODIFIERS [35:0]
+|--LITERAL_CLASS -> class [35:0]
+|--IDENT -> Model [35:6]
+`--OBJBLOCK -> OBJBLOCK [35:11]
+    |--LCURLY -> { [35:11]
+    `--RCURLY -> } [35:12]
+CLASS_DEF -> CLASS_DEF [36:0]
+|--MODIFIERS -> MODIFIERS [36:0]
+|--LITERAL_CLASS -> class [36:0]
+|--IDENT -> Organization [36:6]
+`--OBJBLOCK -> OBJBLOCK [36:18]
+    |--LCURLY -> { [36:18]
+    `--RCURLY -> } [36:19]
+CLASS_DEF -> CLASS_DEF [37:0]
+|--MODIFIERS -> MODIFIERS [37:0]
+|--LITERAL_CLASS -> class [37:0]
+|--IDENT -> ProcessRemoteResourcesMojo [37:6]
+`--OBJBLOCK -> OBJBLOCK [37:32]
+    |--LCURLY -> { [37:32]
+    `--RCURLY -> } [37:33]
+ANNOTATION_DEF -> ANNOTATION_DEF [38:0]
+|--MODIFIERS -> MODIFIERS [38:0]
+|--AT -> @ [38:0]
+|--LITERAL_INTERFACE -> interface [38:1]
+|--IDENT -> Component [38:11]
+`--OBJBLOCK -> OBJBLOCK [38:20]
+    |--LCURLY -> { [38:20]
+    |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [39:4]
+    |   |--MODIFIERS -> MODIFIERS [39:4]
+    |   |--TYPE -> TYPE [39:4]
+    |   |   |--IDENT -> Class [39:4]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [39:9]
+    |   |       |--GENERIC_START -> < [39:9]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [39:10]
+    |   |       |   `--IDENT -> MavenProjectBuilder [39:10]
+    |   |       `--GENERIC_END -> > [39:29]
+    |   |--IDENT -> role [39:31]
+    |   |--LPAREN -> ( [39:35]
+    |   |--RPAREN -> ) [39:36]
+    |   `--SEMI -> ; [39:37]
+    `--RCURLY -> } [40:0]
+CLASS_DEF -> CLASS_DEF [41:0]
+|--MODIFIERS -> MODIFIERS [41:0]
+|--LITERAL_CLASS -> class [41:0]
+|--IDENT -> LifecyclePhase [41:6]
+`--OBJBLOCK -> OBJBLOCK [41:20]
+    |--LCURLY -> { [41:20]
+    |--VARIABLE_DEF -> VARIABLE_DEF [42:4]
+    |   |--MODIFIERS -> MODIFIERS [42:4]
+    |   |   |--LITERAL_PUBLIC -> public [42:4]
+    |   |   |--LITERAL_STATIC -> static [42:11]
+    |   |   `--FINAL -> final [42:18]
+    |   |--TYPE -> TYPE [42:24]
+    |   |   `--IDENT -> Object [42:24]
+    |   |--IDENT -> GENERATE_RESOURCES [42:31]
+    |   |--ASSIGN -> = [42:50]
+    |   |   `--EXPR -> EXPR [42:52]
+    |   |       `--LITERAL_NULL -> null [42:52]
+    |   `--SEMI -> ; [42:56]
+    `--RCURLY -> } [43:0]
+ANNOTATION_DEF -> ANNOTATION_DEF [44:0]
+|--MODIFIERS -> MODIFIERS [44:0]
+|--AT -> @ [44:0]
+|--LITERAL_INTERFACE -> interface [44:1]
+|--IDENT -> Mojo [44:11]
+`--OBJBLOCK -> OBJBLOCK [44:15]
+    |--LCURLY -> { [44:15]
+    |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [45:4]
+    |   |--MODIFIERS -> MODIFIERS [45:4]
+    |   |--TYPE -> TYPE [45:4]
+    |   |   `--IDENT -> String [45:4]
+    |   |--IDENT -> name [45:11]
+    |   |--LPAREN -> ( [45:15]
+    |   |--RPAREN -> ) [45:16]
+    |   `--SEMI -> ; [45:17]
+    `--RCURLY -> } [46:0]
+ANNOTATION_DEF -> ANNOTATION_DEF [47:0]
+|--MODIFIERS -> MODIFIERS [47:0]
+|--AT -> @ [47:0]
+|--LITERAL_INTERFACE -> interface [47:1]
+|--IDENT -> Parameter [47:11]
+`--OBJBLOCK -> OBJBLOCK [47:20]
+    |--LCURLY -> { [47:20]
+    |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [48:4]
+    |   |--MODIFIERS -> MODIFIERS [48:4]
+    |   |--TYPE -> TYPE [48:4]
+    |   |   `--IDENT -> String [48:4]
+    |   |--IDENT -> defaultValue [48:11]
+    |   |--LPAREN -> ( [48:23]
+    |   |--RPAREN -> ) [48:24]
+    |   `--SEMI -> ; [48:25]
+    |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [50:4]
+    |   |--MODIFIERS -> MODIFIERS [50:4]
+    |   |--TYPE -> TYPE [50:4]
+    |   |   `--LITERAL_BOOLEAN -> boolean [50:4]
+    |   |--IDENT -> readonly [50:12]
+    |   |--LPAREN -> ( [50:20]
+    |   |--RPAREN -> ) [50:21]
+    |   `--SEMI -> ; [50:22]
+    `--RCURLY -> } [51:0]
+CLASS_DEF -> CLASS_DEF [52:0]
+|--MODIFIERS -> MODIFIERS [52:0]
+|--LITERAL_CLASS -> class [52:0]
+|--IDENT -> ResolutionScope [52:6]
+`--OBJBLOCK -> OBJBLOCK [52:21]
+    |--LCURLY -> { [52:21]
+    |--VARIABLE_DEF -> VARIABLE_DEF [53:4]
+    |   |--MODIFIERS -> MODIFIERS [53:4]
+    |   |   |--LITERAL_PUBLIC -> public [53:4]
+    |   |   |--LITERAL_STATIC -> static [53:11]
+    |   |   `--FINAL -> final [53:18]
+    |   |--TYPE -> TYPE [53:24]
+    |   |   `--IDENT -> Object [53:24]
+    |   |--IDENT -> RUNTIME [53:31]
+    |   |--ASSIGN -> = [53:39]
+    |   |   `--EXPR -> EXPR [53:41]
+    |   |       `--LITERAL_NULL -> null [53:41]
+    |   `--SEMI -> ; [53:45]
+    `--RCURLY -> } [54:0]
+CLASS_DEF -> CLASS_DEF [55:0]
+|--MODIFIERS -> MODIFIERS [55:0]
+|--LITERAL_CLASS -> class [55:0]
+|--IDENT -> InvalidProjectModelException [55:6]
+`--OBJBLOCK -> OBJBLOCK [55:34]
+    |--LCURLY -> { [55:34]
+    `--RCURLY -> } [55:35]
+CLASS_DEF -> CLASS_DEF [56:0]
+|--MODIFIERS -> MODIFIERS [56:0]
+|--LITERAL_CLASS -> class [56:0]
+|--IDENT -> MavenProject [56:6]
+`--OBJBLOCK -> OBJBLOCK [56:18]
+    |--LCURLY -> { [56:18]
+    `--RCURLY -> } [56:19]
+CLASS_DEF -> CLASS_DEF [57:0]
+|--MODIFIERS -> MODIFIERS [57:0]
+|--LITERAL_CLASS -> class [57:0]
+|--IDENT -> MavenProjectBuilder [57:6]
+`--OBJBLOCK -> OBJBLOCK [57:25]
+    |--LCURLY -> { [57:25]
+    `--RCURLY -> } [57:26]
+CLASS_DEF -> CLASS_DEF [58:0]
+|--MODIFIERS -> MODIFIERS [58:0]
+|--LITERAL_CLASS -> class [58:0]
+|--IDENT -> ProjectBuildingException [58:6]
+`--OBJBLOCK -> OBJBLOCK [58:30]
+    |--LCURLY -> { [58:30]
+    `--RCURLY -> } [58:31]
+CLASS_DEF -> CLASS_DEF [71:0]
+|--MODIFIERS -> MODIFIERS [71:0]
+|   |--ANNOTATION -> ANNOTATION [71:0]
+|   |   |--BLOCK_COMMENT_BEGIN -> /* [60:0]
+|   |   |   |--COMMENT_CONTENT -> *\n * Extends the Maven Remote Resources plugin to fix memory issue found in it, see\n * <a href="https://jira.xwiki.org/browse/XCOMMONS-1421">XCOMMONS-1421</a>.\n * <p>\n * To be removed when <a href="https://issues.apache.org/jira/browse/MRRESOURCES-106">MRRESOURCES-106</a> is fixed on\n * the Maven side.\n *\n * @version $Id: 45afe6a790dc2b72fec66a9f5b0e95e95105bd43 $\n * @since 9.11.5\n * @since 10.5RC1\n  [60:2]
+|   |   |   `--BLOCK_COMMENT_END -> */ [70:1]
+|   |   |--AT -> @ [71:0]
+|   |   |--IDENT -> Mojo [71:1]
+|   |   |--LPAREN -> ( [71:5]
+|   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [71:6]
+|   |   |   |--IDENT -> name [71:6]
+|   |   |   |--ASSIGN -> = [71:11]
+|   |   |   `--EXPR -> EXPR [71:13]
+|   |   |       `--STRING_LITERAL -> "" [71:13]
+|   |   `--RPAREN -> ) [71:15]
+|   `--LITERAL_PUBLIC -> public [72:0]
+|--LITERAL_CLASS -> class [72:7]
+|--IDENT -> InputAntlr4AstRegressionCommentsOnAnnotationsAndEnums [72:13]
+|--EXTENDS_CLAUSE -> extends [73:8]
+|   `--IDENT -> ProcessRemoteResourcesMojo [73:16]
+`--OBJBLOCK -> OBJBLOCK [74:0]
+    |--LCURLY -> { [74:0]
+    |--ENUM_DEF -> ENUM_DEF [80:4]
+    |   |--MODIFIERS -> MODIFIERS [80:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [75:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * Control what is injected in the "projects" Velocity binding.\n     *\n     * @version $Id: 45afe6a790dc2b72fec66a9f5b0e95e95105bd43 $\n      [75:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [79:5]
+    |   |   `--LITERAL_PUBLIC -> public [80:4]
+    |   |--ENUM -> enum [80:11]
+    |   |--IDENT -> ProjectData [80:16]
+    |   `--OBJBLOCK -> OBJBLOCK [81:4]
+    |       |--LCURLY -> { [81:4]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [85:8]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [85:8]
+    |       |   |--BLOCK_COMMENT_BEGIN -> /* [82:8]
+    |       |   |   |--COMMENT_CONTENT -> *\n         * "projects" is empty.\n          [82:10]
+    |       |   |   `--BLOCK_COMMENT_END -> */ [84:9]
+    |       |   `--IDENT -> NONE [85:8]
+    |       |--COMMA -> , [85:12]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [90:8]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [90:8]
+    |       |   |--BLOCK_COMMENT_BEGIN -> /* [87:8]
+    |       |   |   |--COMMENT_CONTENT -> *\n         * "projects" only contains licenses.\n          [87:10]
+    |       |   |   `--BLOCK_COMMENT_END -> */ [89:9]
+    |       |   `--IDENT -> LICENSES [90:8]
+    |       |--COMMA -> , [90:16]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [96:8]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [96:8]
+    |       |   |--BLOCK_COMMENT_BEGIN -> /* [92:8]
+    |       |   |   |--COMMENT_CONTENT -> *\n         * "projects" contains full MavenProject metadata\n         * (very expensive but standard Maven Resource plugin behavior).\n          [92:10]
+    |       |   |   `--BLOCK_COMMENT_END -> */ [95:9]
+    |       |   `--IDENT -> FULL [96:8]
+    |       `--RCURLY -> } [97:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [99:4]
+    |   |--MODIFIERS -> MODIFIERS [99:4]
+    |   |   |--ANNOTATION -> ANNOTATION [99:4]
+    |   |   |   |--AT -> @ [99:4]
+    |   |   |   |--IDENT -> Parameter [99:5]
+    |   |   |   |--LPAREN -> ( [99:14]
+    |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [99:15]
+    |   |   |   |   |--IDENT -> defaultValue [99:15]
+    |   |   |   |   |--ASSIGN -> = [99:28]
+    |   |   |   |   `--EXPR -> EXPR [99:30]
+    |   |   |   |       `--STRING_LITERAL -> "NONE" [99:30]
+    |   |   |   |--COMMA -> , [99:36]
+    |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [99:38]
+    |   |   |   |   |--IDENT -> readonly [99:38]
+    |   |   |   |   |--ASSIGN -> = [99:47]
+    |   |   |   |   `--EXPR -> EXPR [99:49]
+    |   |   |   |       `--LITERAL_FALSE -> false [99:49]
+    |   |   |   `--RPAREN -> ) [99:54]
+    |   |   `--LITERAL_PROTECTED -> protected [100:4]
+    |   |--TYPE -> TYPE [100:14]
+    |   |   `--IDENT -> ProjectData [100:14]
+    |   |--IDENT -> projectsData [100:26]
+    |   `--SEMI -> ; [100:38]
+    |--VARIABLE_DEF -> VARIABLE_DEF [102:4]
+    |   |--MODIFIERS -> MODIFIERS [102:4]
+    |   |   |--ANNOTATION -> ANNOTATION [102:4]
+    |   |   |   |--AT -> @ [102:4]
+    |   |   |   |--IDENT -> Parameter [102:5]
+    |   |   |   |--LPAREN -> ( [102:14]
+    |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [102:15]
+    |   |   |   |   |--IDENT -> defaultValue [102:15]
+    |   |   |   |   |--ASSIGN -> = [102:28]
+    |   |   |   |   `--EXPR -> EXPR [102:30]
+    |   |   |   |       `--STRING_LITERAL -> "${localRepository}" [102:30]
+    |   |   |   |--COMMA -> , [102:50]
+    |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [102:52]
+    |   |   |   |   |--IDENT -> readonly [102:52]
+    |   |   |   |   |--ASSIGN -> = [102:61]
+    |   |   |   |   `--EXPR -> EXPR [102:63]
+    |   |   |   |       `--LITERAL_TRUE -> true [102:63]
+    |   |   |   `--RPAREN -> ) [102:67]
+    |   |   `--LITERAL_PRIVATE -> private [103:4]
+    |   |--TYPE -> TYPE [103:12]
+    |   |   `--IDENT -> ArtifactRepository [103:12]
+    |   |--IDENT -> localRepositoryThis [103:31]
+    |   `--SEMI -> ; [103:50]
+    |--VARIABLE_DEF -> VARIABLE_DEF [105:4]
+    |   |--MODIFIERS -> MODIFIERS [105:4]
+    |   |   |--ANNOTATION -> ANNOTATION [105:4]
+    |   |   |   |--AT -> @ [105:4]
+    |   |   |   |--IDENT -> Component [105:5]
+    |   |   |   |--LPAREN -> ( [105:14]
+    |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [105:15]
+    |   |   |   |   |--IDENT -> role [105:15]
+    |   |   |   |   |--ASSIGN -> = [105:20]
+    |   |   |   |   `--EXPR -> EXPR [105:41]
+    |   |   |   |       `--DOT -> . [105:41]
+    |   |   |   |           |--IDENT -> MavenProjectBuilder [105:22]
+    |   |   |   |           `--LITERAL_CLASS -> class [105:42]
+    |   |   |   `--RPAREN -> ) [105:47]
+    |   |   `--LITERAL_PRIVATE -> private [106:4]
+    |   |--TYPE -> TYPE [106:12]
+    |   |   `--IDENT -> MavenProjectBuilder [106:12]
+    |   |--IDENT -> mavenProjectBuilderThis [106:32]
+    |   `--SEMI -> ; [106:55]
+    |--VARIABLE_DEF -> VARIABLE_DEF [111:4]
+    |   |--MODIFIERS -> MODIFIERS [111:4]
+    |   |   |--ANNOTATION -> ANNOTATION [111:4]
+    |   |   |   |--BLOCK_COMMENT_BEGIN -> /* [108:4]
+    |   |   |   |   |--COMMENT_CONTENT -> *\n     * List of Remote Repositories used by the resolver.\n      [108:6]
+    |   |   |   |   `--BLOCK_COMMENT_END -> */ [110:5]
+    |   |   |   |--AT -> @ [111:4]
+    |   |   |   |--IDENT -> Parameter [111:5]
+    |   |   |   |--LPAREN -> ( [111:14]
+    |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [111:15]
+    |   |   |   |   |--IDENT -> defaultValue [111:15]
+    |   |   |   |   |--ASSIGN -> = [111:28]
+    |   |   |   |   `--EXPR -> EXPR [111:30]
+    |   |   |   |       `--STRING_LITERAL -> "${project.remoteArtifactRepositories}" [111:30]
+    |   |   |   |--COMMA -> , [111:69]
+    |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [111:71]
+    |   |   |   |   |--IDENT -> readonly [111:71]
+    |   |   |   |   |--ASSIGN -> = [111:80]
+    |   |   |   |   `--EXPR -> EXPR [111:82]
+    |   |   |   |       `--LITERAL_TRUE -> true [111:82]
+    |   |   |   `--RPAREN -> ) [111:86]
+    |   |   `--LITERAL_PRIVATE -> private [112:4]
+    |   |--TYPE -> TYPE [112:12]
+    |   |   |--IDENT -> List [112:12]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [112:16]
+    |   |       |--GENERIC_START -> < [112:16]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [112:17]
+    |   |       |   `--IDENT -> ArtifactRepository [112:17]
+    |   |       `--GENERIC_END -> > [112:35]
+    |   |--IDENT -> remoteArtifactRepositoriesThis [112:37]
+    |   `--SEMI -> ; [112:67]
+    |--METHOD_DEF -> METHOD_DEF [114:4]
+    |   |--MODIFIERS -> MODIFIERS [114:4]
+    |   |   `--LITERAL_PRIVATE -> private [114:4]
+    |   |--TYPE -> TYPE [114:12]
+    |   |   `--IDENT -> Logger [114:12]
+    |   |--IDENT -> getLog [114:19]
+    |   |--LPAREN -> ( [114:25]
+    |   |--PARAMETERS -> PARAMETERS [114:26]
+    |   |--RPAREN -> ) [114:26]
+    |   `--SLIST -> { [114:28]
+    |       |--LITERAL_RETURN -> return [115:8]
+    |       |   |--EXPR -> EXPR [115:15]
+    |       |   |   `--LITERAL_NULL -> null [115:15]
+    |       |   `--SEMI -> ; [115:19]
+    |       `--RCURLY -> } [116:4]
+    |--ENUM_DEF -> ENUM_DEF [118:4]
+    |   |--MODIFIERS -> MODIFIERS [118:4]
+    |   |--ENUM -> enum [118:4]
+    |   |--IDENT -> InputJavadocVariableTagsEnum [118:9]
+    |   `--OBJBLOCK -> OBJBLOCK [119:4]
+    |       |--LCURLY -> { [119:4]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [120:8]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [120:8]
+    |       |   `--IDENT -> CONSTANT_A [120:8]
+    |       |--COMMA -> , [120:18]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [125:8]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [125:8]
+    |       |   |--SINGLE_LINE_COMMENT -> // [120:20]
+    |       |   |   `--COMMENT_CONTENT ->  violation\n [120:22]
+    |       |   |--BLOCK_COMMENT_BEGIN -> /* [122:8]
+    |       |   |   |--COMMENT_CONTENT -> *\n         *\n          [122:10]
+    |       |   |   `--BLOCK_COMMENT_END -> */ [124:9]
+    |       |   `--IDENT -> CONSTANT_B [125:8]
+    |       |--COMMA -> , [125:18]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [127:8]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [127:8]
+    |       |   |--IDENT -> CONSTANT_C [127:8]
+    |       |   `--OBJBLOCK -> OBJBLOCK [128:8]
+    |       |       |--SINGLE_LINE_COMMENT -> // [127:19]
+    |       |       |   `--COMMENT_CONTENT ->  violation\n [127:21]
+    |       |       |--LCURLY -> { [128:8]
+    |       |       |--METHOD_DEF -> METHOD_DEF [132:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [132:12]
+    |       |       |   |   |--BLOCK_COMMENT_BEGIN -> /* [129:12]
+    |       |       |   |   |   |--COMMENT_CONTENT -> *\n             *\n              [129:14]
+    |       |       |   |   |   `--BLOCK_COMMENT_END -> */ [131:13]
+    |       |       |   |   `--LITERAL_PUBLIC -> public [132:12]
+    |       |       |   |--TYPE -> TYPE [132:19]
+    |       |       |   |   `--LITERAL_VOID -> void [132:19]
+    |       |       |   |--IDENT -> someMethod [132:24]
+    |       |       |   |--LPAREN -> ( [132:34]
+    |       |       |   |--PARAMETERS -> PARAMETERS [132:35]
+    |       |       |   |--RPAREN -> ) [132:35]
+    |       |       |   `--SLIST -> { [133:12]
+    |       |       |       `--RCURLY -> } [134:12]
+    |       |       |--METHOD_DEF -> METHOD_DEF [136:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [136:12]
+    |       |       |   |   `--LITERAL_PUBLIC -> public [136:12]
+    |       |       |   |--TYPE -> TYPE [136:19]
+    |       |       |   |   `--LITERAL_VOID -> void [136:19]
+    |       |       |   |--IDENT -> someOtherMethod [136:24]
+    |       |       |   |--LPAREN -> ( [136:39]
+    |       |       |   |--PARAMETERS -> PARAMETERS [136:40]
+    |       |       |   |--RPAREN -> ) [136:40]
+    |       |       |   `--SLIST -> { [137:12]
+    |       |       |       `--RCURLY -> } [139:12]
+    |       |       `--RCURLY -> } [140:8]
+    |       `--RCURLY -> } [141:4]
+    `--RCURLY -> } [143:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionConstructorCall.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionConstructorCall.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionConstructorCall.java
@@ -0,0 +1,14 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+public class InputAntlr4AstRegressionConstructorCall {
+    private int f;
+
+    public InputAntlr4AstRegressionConstructorCall(int i) {
+        f = i;
+    }
+
+    public InputAntlr4AstRegressionConstructorCall(float f) {
+        this((int) f);
+    }
+
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionConstructorCall.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionConstructorCall.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionConstructorCall.txt
@@ -0,0 +1,73 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+CLASS_DEF -> CLASS_DEF [3:0]
+|--MODIFIERS -> MODIFIERS [3:0]
+|   `--LITERAL_PUBLIC -> public [3:0]
+|--LITERAL_CLASS -> class [3:7]
+|--IDENT -> InputAntlr4AstRegressionConstructorCall [3:13]
+`--OBJBLOCK -> OBJBLOCK [3:53]
+    |--LCURLY -> { [3:53]
+    |--VARIABLE_DEF -> VARIABLE_DEF [4:4]
+    |   |--MODIFIERS -> MODIFIERS [4:4]
+    |   |   `--LITERAL_PRIVATE -> private [4:4]
+    |   |--TYPE -> TYPE [4:12]
+    |   |   `--LITERAL_INT -> int [4:12]
+    |   |--IDENT -> f [4:16]
+    |   `--SEMI -> ; [4:17]
+    |--CTOR_DEF -> CTOR_DEF [6:4]
+    |   |--MODIFIERS -> MODIFIERS [6:4]
+    |   |   `--LITERAL_PUBLIC -> public [6:4]
+    |   |--IDENT -> InputAntlr4AstRegressionConstructorCall [6:11]
+    |   |--LPAREN -> ( [6:50]
+    |   |--PARAMETERS -> PARAMETERS [6:51]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [6:51]
+    |   |       |--MODIFIERS -> MODIFIERS [6:51]
+    |   |       |--TYPE -> TYPE [6:51]
+    |   |       |   `--LITERAL_INT -> int [6:51]
+    |   |       `--IDENT -> i [6:55]
+    |   |--RPAREN -> ) [6:56]
+    |   `--SLIST -> { [6:58]
+    |       |--EXPR -> EXPR [7:10]
+    |       |   `--ASSIGN -> = [7:10]
+    |       |       |--IDENT -> f [7:8]
+    |       |       `--IDENT -> i [7:12]
+    |       |--SEMI -> ; [7:13]
+    |       `--RCURLY -> } [8:4]
+    |--CTOR_DEF -> CTOR_DEF [10:4]
+    |   |--MODIFIERS -> MODIFIERS [10:4]
+    |   |   `--LITERAL_PUBLIC -> public [10:4]
+    |   |--IDENT -> InputAntlr4AstRegressionConstructorCall [10:11]
+    |   |--LPAREN -> ( [10:50]
+    |   |--PARAMETERS -> PARAMETERS [10:51]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [10:51]
+    |   |       |--MODIFIERS -> MODIFIERS [10:51]
+    |   |       |--TYPE -> TYPE [10:51]
+    |   |       |   `--LITERAL_FLOAT -> float [10:51]
+    |   |       `--IDENT -> f [10:57]
+    |   |--RPAREN -> ) [10:58]
+    |   `--SLIST -> { [10:60]
+    |       |--CTOR_CALL -> this [11:8]
+    |       |   |--LPAREN -> ( [11:12]
+    |       |   |--ELIST -> ELIST [11:13]
+    |       |   |   `--EXPR -> EXPR [11:13]
+    |       |   |       `--TYPECAST -> ( [11:13]
+    |       |   |           |--TYPE -> TYPE [11:14]
+    |       |   |           |   `--LITERAL_INT -> int [11:14]
+    |       |   |           |--RPAREN -> ) [11:17]
+    |       |   |           `--IDENT -> f [11:19]
+    |       |   |--RPAREN -> ) [11:20]
+    |       |   `--SEMI -> ; [11:21]
+    |       `--RCURLY -> } [12:4]
+    `--RCURLY -> } [14:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionEmbeddedBlockComments.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionEmbeddedBlockComments.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionEmbeddedBlockComments.java
@@ -0,0 +1 @@
+package/*2*/com.puppycrawl.tools.checkstyle.grammar.antlr4;
/*13*/
public/*15*/class/*16*/InputAntlr4AstRegressionEmbeddedBlockComments/*49*/{/*
21
*/}
\ No newline at end of file
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionEmbeddedBlockComments.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionEmbeddedBlockComments.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionEmbeddedBlockComments.txt
@@ -0,0 +1,22 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:51]
+|--DOT -> . [1:51]
+|   |--DOT -> . [1:43]
+|   |   |--DOT -> . [1:32]
+|   |   |   |--DOT -> . [1:26]
+|   |   |   |   |--DOT -> . [1:15]
+|   |   |   |   |   |--IDENT -> com [1:12]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:16]
+|   |   |   |   `--IDENT -> tools [1:27]
+|   |   |   `--IDENT -> checkstyle [1:33]
+|   |   `--IDENT -> grammar [1:44]
+|   `--IDENT -> antlr4 [1:52]
+`--SEMI -> ; [1:58]
+CLASS_DEF -> CLASS_DEF [3:0]
+|--MODIFIERS -> MODIFIERS [3:0]
+|   `--LITERAL_PUBLIC -> public [3:0]
+|--LITERAL_CLASS -> class [3:12]
+|--IDENT -> InputAntlr4AstRegressionEmbeddedBlockComments [3:23]
+`--OBJBLOCK -> OBJBLOCK [3:74]
+    |--LCURLY -> { [3:74]
+    `--RCURLY -> } [5:2]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionExplicitInitialization.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionExplicitInitialization.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionExplicitInitialization.java
@@ -0,0 +1,91 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+public class InputAntlr4AstRegressionExplicitInitialization {
+    private int x = 0;
+    private Object bar = /* comment test */null;
+    private int y = 1;
+    private long y1 = 1 - 1;
+    private long y3;
+    private long y4 = 0L;
+    private boolean b1 = false;
+    private boolean b2 = true;
+    private boolean b3;
+    private String str = "";
+    java.lang.String str1 = null, str3 = null;
+    int ar1[] = null;
+    int ar2[] = new int[1];
+    int ar3[];
+    float f1 = 0f;
+    double d1 = 0.0;
+
+    static char ch;
+    static char ch1 = 0;
+    static char ch2 = '\0';
+    static char ch3 = '\1';
+
+    void method() {
+        int xx = 0;
+        String s = null;
+    }
+}
+
+interface interface1{
+    int TOKEN_first = 0x00;
+    int TOKEN_second = 0x01;
+    int TOKEN_third = 0x02;
+}
+
+class InputExplicitInit2 {
+    private Bar<String> bar = null;
+    private Bar<String>[] barArray = null;
+}
+
+enum InputExplicitInit3 {
+    A,
+    B
+    {
+        private int x = 0;
+        private Bar<String> bar = null;
+        private Bar<String>[] barArray = null;
+        private int y = 1;
+    };
+    private int x = 0;
+    private Bar<String> bar = null;
+    private Bar<String>[] barArray = null;
+    private int y = 1;
+    private Boolean booleanAtt = false;
+}
+
+@interface annotation1{
+    int TOKEN_first = 0x00;
+    int TOKEN_second = 0x01;
+    int TOKEN_third = 0x02;
+}
+
+class ForEach {
+    public ForEach(java.util.Collection<String> strings)
+    {
+        for(String s : strings) //this should not even be checked
+        {
+
+        }
+    }
+}
+
+class Bar<T> {
+}
+
+class Chars {
+    char a;
+    char b = a;
+    byte c = 1;
+    short d = 1;
+    final long e = 0;
+}
+
+class Doubles {
+    final double subZero = -0.0;
+    final double nan = Double.NaN;
+    private short shortVariable = 0;
+    private byte bite = 0;
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionExplicitInitialization.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionExplicitInitialization.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionExplicitInitialization.txt
@@ -0,0 +1,658 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+CLASS_DEF -> CLASS_DEF [3:0]
+|--MODIFIERS -> MODIFIERS [3:0]
+|   `--LITERAL_PUBLIC -> public [3:0]
+|--LITERAL_CLASS -> class [3:7]
+|--IDENT -> InputAntlr4AstRegressionExplicitInitialization [3:13]
+`--OBJBLOCK -> OBJBLOCK [3:60]
+    |--LCURLY -> { [3:60]
+    |--VARIABLE_DEF -> VARIABLE_DEF [4:4]
+    |   |--MODIFIERS -> MODIFIERS [4:4]
+    |   |   `--LITERAL_PRIVATE -> private [4:4]
+    |   |--TYPE -> TYPE [4:12]
+    |   |   `--LITERAL_INT -> int [4:12]
+    |   |--IDENT -> x [4:16]
+    |   |--ASSIGN -> = [4:18]
+    |   |   `--EXPR -> EXPR [4:20]
+    |   |       `--NUM_INT -> 0 [4:20]
+    |   `--SEMI -> ; [4:21]
+    |--VARIABLE_DEF -> VARIABLE_DEF [5:4]
+    |   |--MODIFIERS -> MODIFIERS [5:4]
+    |   |   `--LITERAL_PRIVATE -> private [5:4]
+    |   |--TYPE -> TYPE [5:12]
+    |   |   `--IDENT -> Object [5:12]
+    |   |--IDENT -> bar [5:19]
+    |   |--ASSIGN -> = [5:23]
+    |   |   `--EXPR -> EXPR [5:43]
+    |   |       `--LITERAL_NULL -> null [5:43]
+    |   `--SEMI -> ; [5:47]
+    |--VARIABLE_DEF -> VARIABLE_DEF [6:4]
+    |   |--MODIFIERS -> MODIFIERS [6:4]
+    |   |   `--LITERAL_PRIVATE -> private [6:4]
+    |   |--TYPE -> TYPE [6:12]
+    |   |   `--LITERAL_INT -> int [6:12]
+    |   |--IDENT -> y [6:16]
+    |   |--ASSIGN -> = [6:18]
+    |   |   `--EXPR -> EXPR [6:20]
+    |   |       `--NUM_INT -> 1 [6:20]
+    |   `--SEMI -> ; [6:21]
+    |--VARIABLE_DEF -> VARIABLE_DEF [7:4]
+    |   |--MODIFIERS -> MODIFIERS [7:4]
+    |   |   `--LITERAL_PRIVATE -> private [7:4]
+    |   |--TYPE -> TYPE [7:12]
+    |   |   `--LITERAL_LONG -> long [7:12]
+    |   |--IDENT -> y1 [7:17]
+    |   |--ASSIGN -> = [7:20]
+    |   |   `--EXPR -> EXPR [7:24]
+    |   |       `--MINUS -> - [7:24]
+    |   |           |--NUM_INT -> 1 [7:22]
+    |   |           `--NUM_INT -> 1 [7:26]
+    |   `--SEMI -> ; [7:27]
+    |--VARIABLE_DEF -> VARIABLE_DEF [8:4]
+    |   |--MODIFIERS -> MODIFIERS [8:4]
+    |   |   `--LITERAL_PRIVATE -> private [8:4]
+    |   |--TYPE -> TYPE [8:12]
+    |   |   `--LITERAL_LONG -> long [8:12]
+    |   |--IDENT -> y3 [8:17]
+    |   `--SEMI -> ; [8:19]
+    |--VARIABLE_DEF -> VARIABLE_DEF [9:4]
+    |   |--MODIFIERS -> MODIFIERS [9:4]
+    |   |   `--LITERAL_PRIVATE -> private [9:4]
+    |   |--TYPE -> TYPE [9:12]
+    |   |   `--LITERAL_LONG -> long [9:12]
+    |   |--IDENT -> y4 [9:17]
+    |   |--ASSIGN -> = [9:20]
+    |   |   `--EXPR -> EXPR [9:22]
+    |   |       `--NUM_LONG -> 0L [9:22]
+    |   `--SEMI -> ; [9:24]
+    |--VARIABLE_DEF -> VARIABLE_DEF [10:4]
+    |   |--MODIFIERS -> MODIFIERS [10:4]
+    |   |   `--LITERAL_PRIVATE -> private [10:4]
+    |   |--TYPE -> TYPE [10:12]
+    |   |   `--LITERAL_BOOLEAN -> boolean [10:12]
+    |   |--IDENT -> b1 [10:20]
+    |   |--ASSIGN -> = [10:23]
+    |   |   `--EXPR -> EXPR [10:25]
+    |   |       `--LITERAL_FALSE -> false [10:25]
+    |   `--SEMI -> ; [10:30]
+    |--VARIABLE_DEF -> VARIABLE_DEF [11:4]
+    |   |--MODIFIERS -> MODIFIERS [11:4]
+    |   |   `--LITERAL_PRIVATE -> private [11:4]
+    |   |--TYPE -> TYPE [11:12]
+    |   |   `--LITERAL_BOOLEAN -> boolean [11:12]
+    |   |--IDENT -> b2 [11:20]
+    |   |--ASSIGN -> = [11:23]
+    |   |   `--EXPR -> EXPR [11:25]
+    |   |       `--LITERAL_TRUE -> true [11:25]
+    |   `--SEMI -> ; [11:29]
+    |--VARIABLE_DEF -> VARIABLE_DEF [12:4]
+    |   |--MODIFIERS -> MODIFIERS [12:4]
+    |   |   `--LITERAL_PRIVATE -> private [12:4]
+    |   |--TYPE -> TYPE [12:12]
+    |   |   `--LITERAL_BOOLEAN -> boolean [12:12]
+    |   |--IDENT -> b3 [12:20]
+    |   `--SEMI -> ; [12:22]
+    |--VARIABLE_DEF -> VARIABLE_DEF [13:4]
+    |   |--MODIFIERS -> MODIFIERS [13:4]
+    |   |   `--LITERAL_PRIVATE -> private [13:4]
+    |   |--TYPE -> TYPE [13:12]
+    |   |   `--IDENT -> String [13:12]
+    |   |--IDENT -> str [13:19]
+    |   |--ASSIGN -> = [13:23]
+    |   |   `--EXPR -> EXPR [13:25]
+    |   |       `--STRING_LITERAL -> "" [13:25]
+    |   `--SEMI -> ; [13:27]
+    |--VARIABLE_DEF -> VARIABLE_DEF [14:13]
+    |   |--MODIFIERS -> MODIFIERS [14:13]
+    |   |--TYPE -> TYPE [14:13]
+    |   |   `--DOT -> . [14:13]
+    |   |       |--DOT -> . [14:8]
+    |   |       |   |--IDENT -> java [14:4]
+    |   |       |   `--IDENT -> lang [14:9]
+    |   |       `--IDENT -> String [14:14]
+    |   |--IDENT -> str1 [14:21]
+    |   |--ASSIGN -> = [14:26]
+    |   |   `--EXPR -> EXPR [14:28]
+    |   |       `--LITERAL_NULL -> null [14:28]
+    |   `--SEMI -> ; [14:45]
+    |--COMMA -> , [14:32]
+    |--VARIABLE_DEF -> VARIABLE_DEF [14:13]
+    |   |--MODIFIERS -> MODIFIERS [14:13]
+    |   |--TYPE -> TYPE [14:13]
+    |   |   `--DOT -> . [14:13]
+    |   |       |--DOT -> . [14:8]
+    |   |       |   |--IDENT -> java [14:4]
+    |   |       |   `--IDENT -> lang [14:9]
+    |   |       `--IDENT -> String [14:14]
+    |   |--IDENT -> str3 [14:34]
+    |   `--ASSIGN -> = [14:39]
+    |       `--EXPR -> EXPR [14:41]
+    |           `--LITERAL_NULL -> null [14:41]
+    |--VARIABLE_DEF -> VARIABLE_DEF [15:4]
+    |   |--MODIFIERS -> MODIFIERS [15:4]
+    |   |--TYPE -> TYPE [15:4]
+    |   |   |--LITERAL_INT -> int [15:4]
+    |   |   `--ARRAY_DECLARATOR -> [ [15:11]
+    |   |       `--RBRACK -> ] [15:12]
+    |   |--IDENT -> ar1 [15:8]
+    |   |--ASSIGN -> = [15:14]
+    |   |   `--EXPR -> EXPR [15:16]
+    |   |       `--LITERAL_NULL -> null [15:16]
+    |   `--SEMI -> ; [15:20]
+    |--VARIABLE_DEF -> VARIABLE_DEF [16:4]
+    |   |--MODIFIERS -> MODIFIERS [16:4]
+    |   |--TYPE -> TYPE [16:4]
+    |   |   |--LITERAL_INT -> int [16:4]
+    |   |   `--ARRAY_DECLARATOR -> [ [16:11]
+    |   |       `--RBRACK -> ] [16:12]
+    |   |--IDENT -> ar2 [16:8]
+    |   |--ASSIGN -> = [16:14]
+    |   |   `--EXPR -> EXPR [16:16]
+    |   |       `--LITERAL_NEW -> new [16:16]
+    |   |           |--LITERAL_INT -> int [16:20]
+    |   |           `--ARRAY_DECLARATOR -> [ [16:23]
+    |   |               |--EXPR -> EXPR [16:24]
+    |   |               |   `--NUM_INT -> 1 [16:24]
+    |   |               `--RBRACK -> ] [16:25]
+    |   `--SEMI -> ; [16:26]
+    |--VARIABLE_DEF -> VARIABLE_DEF [17:4]
+    |   |--MODIFIERS -> MODIFIERS [17:4]
+    |   |--TYPE -> TYPE [17:4]
+    |   |   |--LITERAL_INT -> int [17:4]
+    |   |   `--ARRAY_DECLARATOR -> [ [17:11]
+    |   |       `--RBRACK -> ] [17:12]
+    |   |--IDENT -> ar3 [17:8]
+    |   `--SEMI -> ; [17:13]
+    |--VARIABLE_DEF -> VARIABLE_DEF [18:4]
+    |   |--MODIFIERS -> MODIFIERS [18:4]
+    |   |--TYPE -> TYPE [18:4]
+    |   |   `--LITERAL_FLOAT -> float [18:4]
+    |   |--IDENT -> f1 [18:10]
+    |   |--ASSIGN -> = [18:13]
+    |   |   `--EXPR -> EXPR [18:15]
+    |   |       `--NUM_FLOAT -> 0f [18:15]
+    |   `--SEMI -> ; [18:17]
+    |--VARIABLE_DEF -> VARIABLE_DEF [19:4]
+    |   |--MODIFIERS -> MODIFIERS [19:4]
+    |   |--TYPE -> TYPE [19:4]
+    |   |   `--LITERAL_DOUBLE -> double [19:4]
+    |   |--IDENT -> d1 [19:11]
+    |   |--ASSIGN -> = [19:14]
+    |   |   `--EXPR -> EXPR [19:16]
+    |   |       `--NUM_FLOAT -> 0.0 [19:16]
+    |   `--SEMI -> ; [19:19]
+    |--VARIABLE_DEF -> VARIABLE_DEF [21:4]
+    |   |--MODIFIERS -> MODIFIERS [21:4]
+    |   |   `--LITERAL_STATIC -> static [21:4]
+    |   |--TYPE -> TYPE [21:11]
+    |   |   `--LITERAL_CHAR -> char [21:11]
+    |   |--IDENT -> ch [21:16]
+    |   `--SEMI -> ; [21:18]
+    |--VARIABLE_DEF -> VARIABLE_DEF [22:4]
+    |   |--MODIFIERS -> MODIFIERS [22:4]
+    |   |   `--LITERAL_STATIC -> static [22:4]
+    |   |--TYPE -> TYPE [22:11]
+    |   |   `--LITERAL_CHAR -> char [22:11]
+    |   |--IDENT -> ch1 [22:16]
+    |   |--ASSIGN -> = [22:20]
+    |   |   `--EXPR -> EXPR [22:22]
+    |   |       `--NUM_INT -> 0 [22:22]
+    |   `--SEMI -> ; [22:23]
+    |--VARIABLE_DEF -> VARIABLE_DEF [23:4]
+    |   |--MODIFIERS -> MODIFIERS [23:4]
+    |   |   `--LITERAL_STATIC -> static [23:4]
+    |   |--TYPE -> TYPE [23:11]
+    |   |   `--LITERAL_CHAR -> char [23:11]
+    |   |--IDENT -> ch2 [23:16]
+    |   |--ASSIGN -> = [23:20]
+    |   |   `--EXPR -> EXPR [23:22]
+    |   |       `--CHAR_LITERAL -> '\0' [23:22]
+    |   `--SEMI -> ; [23:26]
+    |--VARIABLE_DEF -> VARIABLE_DEF [24:4]
+    |   |--MODIFIERS -> MODIFIERS [24:4]
+    |   |   `--LITERAL_STATIC -> static [24:4]
+    |   |--TYPE -> TYPE [24:11]
+    |   |   `--LITERAL_CHAR -> char [24:11]
+    |   |--IDENT -> ch3 [24:16]
+    |   |--ASSIGN -> = [24:20]
+    |   |   `--EXPR -> EXPR [24:22]
+    |   |       `--CHAR_LITERAL -> '\1' [24:22]
+    |   `--SEMI -> ; [24:26]
+    |--METHOD_DEF -> METHOD_DEF [26:4]
+    |   |--MODIFIERS -> MODIFIERS [26:4]
+    |   |--TYPE -> TYPE [26:4]
+    |   |   `--LITERAL_VOID -> void [26:4]
+    |   |--IDENT -> method [26:9]
+    |   |--LPAREN -> ( [26:15]
+    |   |--PARAMETERS -> PARAMETERS [26:16]
+    |   |--RPAREN -> ) [26:16]
+    |   `--SLIST -> { [26:18]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [27:8]
+    |       |   |--MODIFIERS -> MODIFIERS [27:8]
+    |       |   |--TYPE -> TYPE [27:8]
+    |       |   |   `--LITERAL_INT -> int [27:8]
+    |       |   |--IDENT -> xx [27:12]
+    |       |   `--ASSIGN -> = [27:15]
+    |       |       `--EXPR -> EXPR [27:17]
+    |       |           `--NUM_INT -> 0 [27:17]
+    |       |--SEMI -> ; [27:18]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [28:8]
+    |       |   |--MODIFIERS -> MODIFIERS [28:8]
+    |       |   |--TYPE -> TYPE [28:8]
+    |       |   |   `--IDENT -> String [28:8]
+    |       |   |--IDENT -> s [28:15]
+    |       |   `--ASSIGN -> = [28:17]
+    |       |       `--EXPR -> EXPR [28:19]
+    |       |           `--LITERAL_NULL -> null [28:19]
+    |       |--SEMI -> ; [28:23]
+    |       `--RCURLY -> } [29:4]
+    `--RCURLY -> } [30:0]
+INTERFACE_DEF -> INTERFACE_DEF [32:0]
+|--MODIFIERS -> MODIFIERS [32:0]
+|--LITERAL_INTERFACE -> interface [32:0]
+|--IDENT -> interface1 [32:10]
+`--OBJBLOCK -> OBJBLOCK [32:20]
+    |--LCURLY -> { [32:20]
+    |--VARIABLE_DEF -> VARIABLE_DEF [33:4]
+    |   |--MODIFIERS -> MODIFIERS [33:4]
+    |   |--TYPE -> TYPE [33:4]
+    |   |   `--LITERAL_INT -> int [33:4]
+    |   |--IDENT -> TOKEN_first [33:8]
+    |   |--ASSIGN -> = [33:20]
+    |   |   `--EXPR -> EXPR [33:22]
+    |   |       `--NUM_INT -> 0x00 [33:22]
+    |   `--SEMI -> ; [33:26]
+    |--VARIABLE_DEF -> VARIABLE_DEF [34:4]
+    |   |--MODIFIERS -> MODIFIERS [34:4]
+    |   |--TYPE -> TYPE [34:4]
+    |   |   `--LITERAL_INT -> int [34:4]
+    |   |--IDENT -> TOKEN_second [34:8]
+    |   |--ASSIGN -> = [34:21]
+    |   |   `--EXPR -> EXPR [34:23]
+    |   |       `--NUM_INT -> 0x01 [34:23]
+    |   `--SEMI -> ; [34:27]
+    |--VARIABLE_DEF -> VARIABLE_DEF [35:4]
+    |   |--MODIFIERS -> MODIFIERS [35:4]
+    |   |--TYPE -> TYPE [35:4]
+    |   |   `--LITERAL_INT -> int [35:4]
+    |   |--IDENT -> TOKEN_third [35:8]
+    |   |--ASSIGN -> = [35:20]
+    |   |   `--EXPR -> EXPR [35:22]
+    |   |       `--NUM_INT -> 0x02 [35:22]
+    |   `--SEMI -> ; [35:26]
+    `--RCURLY -> } [36:0]
+CLASS_DEF -> CLASS_DEF [38:0]
+|--MODIFIERS -> MODIFIERS [38:0]
+|--LITERAL_CLASS -> class [38:0]
+|--IDENT -> InputExplicitInit2 [38:6]
+`--OBJBLOCK -> OBJBLOCK [38:25]
+    |--LCURLY -> { [38:25]
+    |--VARIABLE_DEF -> VARIABLE_DEF [39:4]
+    |   |--MODIFIERS -> MODIFIERS [39:4]
+    |   |   `--LITERAL_PRIVATE -> private [39:4]
+    |   |--TYPE -> TYPE [39:12]
+    |   |   |--IDENT -> Bar [39:12]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [39:15]
+    |   |       |--GENERIC_START -> < [39:15]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [39:16]
+    |   |       |   `--IDENT -> String [39:16]
+    |   |       `--GENERIC_END -> > [39:22]
+    |   |--IDENT -> bar [39:24]
+    |   |--ASSIGN -> = [39:28]
+    |   |   `--EXPR -> EXPR [39:30]
+    |   |       `--LITERAL_NULL -> null [39:30]
+    |   `--SEMI -> ; [39:34]
+    |--VARIABLE_DEF -> VARIABLE_DEF [40:4]
+    |   |--MODIFIERS -> MODIFIERS [40:4]
+    |   |   `--LITERAL_PRIVATE -> private [40:4]
+    |   |--TYPE -> TYPE [40:12]
+    |   |   |--IDENT -> Bar [40:12]
+    |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [40:15]
+    |   |   |   |--GENERIC_START -> < [40:15]
+    |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [40:16]
+    |   |   |   |   `--IDENT -> String [40:16]
+    |   |   |   `--GENERIC_END -> > [40:22]
+    |   |   `--ARRAY_DECLARATOR -> [ [40:23]
+    |   |       `--RBRACK -> ] [40:24]
+    |   |--IDENT -> barArray [40:26]
+    |   |--ASSIGN -> = [40:35]
+    |   |   `--EXPR -> EXPR [40:37]
+    |   |       `--LITERAL_NULL -> null [40:37]
+    |   `--SEMI -> ; [40:41]
+    `--RCURLY -> } [41:0]
+ENUM_DEF -> ENUM_DEF [43:0]
+|--MODIFIERS -> MODIFIERS [43:0]
+|--ENUM -> enum [43:0]
+|--IDENT -> InputExplicitInit3 [43:5]
+`--OBJBLOCK -> OBJBLOCK [43:24]
+    |--LCURLY -> { [43:24]
+    |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [44:4]
+    |   |--ANNOTATIONS -> ANNOTATIONS [44:4]
+    |   `--IDENT -> A [44:4]
+    |--COMMA -> , [44:5]
+    |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [45:4]
+    |   |--ANNOTATIONS -> ANNOTATIONS [45:4]
+    |   |--IDENT -> B [45:4]
+    |   `--OBJBLOCK -> OBJBLOCK [46:4]
+    |       |--LCURLY -> { [46:4]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [47:8]
+    |       |   |--MODIFIERS -> MODIFIERS [47:8]
+    |       |   |   `--LITERAL_PRIVATE -> private [47:8]
+    |       |   |--TYPE -> TYPE [47:16]
+    |       |   |   `--LITERAL_INT -> int [47:16]
+    |       |   |--IDENT -> x [47:20]
+    |       |   |--ASSIGN -> = [47:22]
+    |       |   |   `--EXPR -> EXPR [47:24]
+    |       |   |       `--NUM_INT -> 0 [47:24]
+    |       |   `--SEMI -> ; [47:25]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [48:8]
+    |       |   |--MODIFIERS -> MODIFIERS [48:8]
+    |       |   |   `--LITERAL_PRIVATE -> private [48:8]
+    |       |   |--TYPE -> TYPE [48:16]
+    |       |   |   |--IDENT -> Bar [48:16]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [48:19]
+    |       |   |       |--GENERIC_START -> < [48:19]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [48:20]
+    |       |   |       |   `--IDENT -> String [48:20]
+    |       |   |       `--GENERIC_END -> > [48:26]
+    |       |   |--IDENT -> bar [48:28]
+    |       |   |--ASSIGN -> = [48:32]
+    |       |   |   `--EXPR -> EXPR [48:34]
+    |       |   |       `--LITERAL_NULL -> null [48:34]
+    |       |   `--SEMI -> ; [48:38]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [49:8]
+    |       |   |--MODIFIERS -> MODIFIERS [49:8]
+    |       |   |   `--LITERAL_PRIVATE -> private [49:8]
+    |       |   |--TYPE -> TYPE [49:16]
+    |       |   |   |--IDENT -> Bar [49:16]
+    |       |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [49:19]
+    |       |   |   |   |--GENERIC_START -> < [49:19]
+    |       |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [49:20]
+    |       |   |   |   |   `--IDENT -> String [49:20]
+    |       |   |   |   `--GENERIC_END -> > [49:26]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [49:27]
+    |       |   |       `--RBRACK -> ] [49:28]
+    |       |   |--IDENT -> barArray [49:30]
+    |       |   |--ASSIGN -> = [49:39]
+    |       |   |   `--EXPR -> EXPR [49:41]
+    |       |   |       `--LITERAL_NULL -> null [49:41]
+    |       |   `--SEMI -> ; [49:45]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [50:8]
+    |       |   |--MODIFIERS -> MODIFIERS [50:8]
+    |       |   |   `--LITERAL_PRIVATE -> private [50:8]
+    |       |   |--TYPE -> TYPE [50:16]
+    |       |   |   `--LITERAL_INT -> int [50:16]
+    |       |   |--IDENT -> y [50:20]
+    |       |   |--ASSIGN -> = [50:22]
+    |       |   |   `--EXPR -> EXPR [50:24]
+    |       |   |       `--NUM_INT -> 1 [50:24]
+    |       |   `--SEMI -> ; [50:25]
+    |       `--RCURLY -> } [51:4]
+    |--SEMI -> ; [51:5]
+    |--VARIABLE_DEF -> VARIABLE_DEF [52:4]
+    |   |--MODIFIERS -> MODIFIERS [52:4]
+    |   |   `--LITERAL_PRIVATE -> private [52:4]
+    |   |--TYPE -> TYPE [52:12]
+    |   |   `--LITERAL_INT -> int [52:12]
+    |   |--IDENT -> x [52:16]
+    |   |--ASSIGN -> = [52:18]
+    |   |   `--EXPR -> EXPR [52:20]
+    |   |       `--NUM_INT -> 0 [52:20]
+    |   `--SEMI -> ; [52:21]
+    |--VARIABLE_DEF -> VARIABLE_DEF [53:4]
+    |   |--MODIFIERS -> MODIFIERS [53:4]
+    |   |   `--LITERAL_PRIVATE -> private [53:4]
+    |   |--TYPE -> TYPE [53:12]
+    |   |   |--IDENT -> Bar [53:12]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [53:15]
+    |   |       |--GENERIC_START -> < [53:15]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [53:16]
+    |   |       |   `--IDENT -> String [53:16]
+    |   |       `--GENERIC_END -> > [53:22]
+    |   |--IDENT -> bar [53:24]
+    |   |--ASSIGN -> = [53:28]
+    |   |   `--EXPR -> EXPR [53:30]
+    |   |       `--LITERAL_NULL -> null [53:30]
+    |   `--SEMI -> ; [53:34]
+    |--VARIABLE_DEF -> VARIABLE_DEF [54:4]
+    |   |--MODIFIERS -> MODIFIERS [54:4]
+    |   |   `--LITERAL_PRIVATE -> private [54:4]
+    |   |--TYPE -> TYPE [54:12]
+    |   |   |--IDENT -> Bar [54:12]
+    |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [54:15]
+    |   |   |   |--GENERIC_START -> < [54:15]
+    |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [54:16]
+    |   |   |   |   `--IDENT -> String [54:16]
+    |   |   |   `--GENERIC_END -> > [54:22]
+    |   |   `--ARRAY_DECLARATOR -> [ [54:23]
+    |   |       `--RBRACK -> ] [54:24]
+    |   |--IDENT -> barArray [54:26]
+    |   |--ASSIGN -> = [54:35]
+    |   |   `--EXPR -> EXPR [54:37]
+    |   |       `--LITERAL_NULL -> null [54:37]
+    |   `--SEMI -> ; [54:41]
+    |--VARIABLE_DEF -> VARIABLE_DEF [55:4]
+    |   |--MODIFIERS -> MODIFIERS [55:4]
+    |   |   `--LITERAL_PRIVATE -> private [55:4]
+    |   |--TYPE -> TYPE [55:12]
+    |   |   `--LITERAL_INT -> int [55:12]
+    |   |--IDENT -> y [55:16]
+    |   |--ASSIGN -> = [55:18]
+    |   |   `--EXPR -> EXPR [55:20]
+    |   |       `--NUM_INT -> 1 [55:20]
+    |   `--SEMI -> ; [55:21]
+    |--VARIABLE_DEF -> VARIABLE_DEF [56:4]
+    |   |--MODIFIERS -> MODIFIERS [56:4]
+    |   |   `--LITERAL_PRIVATE -> private [56:4]
+    |   |--TYPE -> TYPE [56:12]
+    |   |   `--IDENT -> Boolean [56:12]
+    |   |--IDENT -> booleanAtt [56:20]
+    |   |--ASSIGN -> = [56:31]
+    |   |   `--EXPR -> EXPR [56:33]
+    |   |       `--LITERAL_FALSE -> false [56:33]
+    |   `--SEMI -> ; [56:38]
+    `--RCURLY -> } [57:0]
+ANNOTATION_DEF -> ANNOTATION_DEF [59:0]
+|--MODIFIERS -> MODIFIERS [59:0]
+|--AT -> @ [59:0]
+|--LITERAL_INTERFACE -> interface [59:1]
+|--IDENT -> annotation1 [59:11]
+`--OBJBLOCK -> OBJBLOCK [59:22]
+    |--LCURLY -> { [59:22]
+    |--VARIABLE_DEF -> VARIABLE_DEF [60:4]
+    |   |--MODIFIERS -> MODIFIERS [60:4]
+    |   |--TYPE -> TYPE [60:4]
+    |   |   `--LITERAL_INT -> int [60:4]
+    |   |--IDENT -> TOKEN_first [60:8]
+    |   |--ASSIGN -> = [60:20]
+    |   |   `--EXPR -> EXPR [60:22]
+    |   |       `--NUM_INT -> 0x00 [60:22]
+    |   `--SEMI -> ; [60:26]
+    |--VARIABLE_DEF -> VARIABLE_DEF [61:4]
+    |   |--MODIFIERS -> MODIFIERS [61:4]
+    |   |--TYPE -> TYPE [61:4]
+    |   |   `--LITERAL_INT -> int [61:4]
+    |   |--IDENT -> TOKEN_second [61:8]
+    |   |--ASSIGN -> = [61:21]
+    |   |   `--EXPR -> EXPR [61:23]
+    |   |       `--NUM_INT -> 0x01 [61:23]
+    |   `--SEMI -> ; [61:27]
+    |--VARIABLE_DEF -> VARIABLE_DEF [62:4]
+    |   |--MODIFIERS -> MODIFIERS [62:4]
+    |   |--TYPE -> TYPE [62:4]
+    |   |   `--LITERAL_INT -> int [62:4]
+    |   |--IDENT -> TOKEN_third [62:8]
+    |   |--ASSIGN -> = [62:20]
+    |   |   `--EXPR -> EXPR [62:22]
+    |   |       `--NUM_INT -> 0x02 [62:22]
+    |   `--SEMI -> ; [62:26]
+    `--RCURLY -> } [63:0]
+CLASS_DEF -> CLASS_DEF [65:0]
+|--MODIFIERS -> MODIFIERS [65:0]
+|--LITERAL_CLASS -> class [65:0]
+|--IDENT -> ForEach [65:6]
+`--OBJBLOCK -> OBJBLOCK [65:14]
+    |--LCURLY -> { [65:14]
+    |--CTOR_DEF -> CTOR_DEF [66:4]
+    |   |--MODIFIERS -> MODIFIERS [66:4]
+    |   |   `--LITERAL_PUBLIC -> public [66:4]
+    |   |--IDENT -> ForEach [66:11]
+    |   |--LPAREN -> ( [66:18]
+    |   |--PARAMETERS -> PARAMETERS [66:28]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [66:28]
+    |   |       |--MODIFIERS -> MODIFIERS [66:28]
+    |   |       |--TYPE -> TYPE [66:28]
+    |   |       |   `--DOT -> . [66:28]
+    |   |       |       |--DOT -> . [66:23]
+    |   |       |       |   |--IDENT -> java [66:19]
+    |   |       |       |   `--IDENT -> util [66:24]
+    |   |       |       |--IDENT -> Collection [66:29]
+    |   |       |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [66:39]
+    |   |       |           |--GENERIC_START -> < [66:39]
+    |   |       |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [66:40]
+    |   |       |           |   `--IDENT -> String [66:40]
+    |   |       |           `--GENERIC_END -> > [66:46]
+    |   |       `--IDENT -> strings [66:48]
+    |   |--RPAREN -> ) [66:55]
+    |   `--SLIST -> { [67:4]
+    |       |--LITERAL_FOR -> for [68:8]
+    |       |   |--LPAREN -> ( [68:11]
+    |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [68:12]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [68:12]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [68:12]
+    |       |   |   |   |--TYPE -> TYPE [68:12]
+    |       |   |   |   |   `--IDENT -> String [68:12]
+    |       |   |   |   `--IDENT -> s [68:19]
+    |       |   |   |--COLON -> : [68:21]
+    |       |   |   `--EXPR -> EXPR [68:23]
+    |       |   |       `--IDENT -> strings [68:23]
+    |       |   |--RPAREN -> ) [68:30]
+    |       |   `--SLIST -> { [69:8]
+    |       |       `--RCURLY -> } [71:8]
+    |       `--RCURLY -> } [72:4]
+    `--RCURLY -> } [73:0]
+CLASS_DEF -> CLASS_DEF [75:0]
+|--MODIFIERS -> MODIFIERS [75:0]
+|--LITERAL_CLASS -> class [75:0]
+|--IDENT -> Bar [75:6]
+|--TYPE_PARAMETERS -> TYPE_PARAMETERS [75:9]
+|   |--GENERIC_START -> < [75:9]
+|   |--TYPE_PARAMETER -> TYPE_PARAMETER [75:10]
+|   |   `--IDENT -> T [75:10]
+|   `--GENERIC_END -> > [75:11]
+`--OBJBLOCK -> OBJBLOCK [75:13]
+    |--LCURLY -> { [75:13]
+    `--RCURLY -> } [76:0]
+CLASS_DEF -> CLASS_DEF [78:0]
+|--MODIFIERS -> MODIFIERS [78:0]
+|--LITERAL_CLASS -> class [78:0]
+|--IDENT -> Chars [78:6]
+`--OBJBLOCK -> OBJBLOCK [78:12]
+    |--LCURLY -> { [78:12]
+    |--VARIABLE_DEF -> VARIABLE_DEF [79:4]
+    |   |--MODIFIERS -> MODIFIERS [79:4]
+    |   |--TYPE -> TYPE [79:4]
+    |   |   `--LITERAL_CHAR -> char [79:4]
+    |   |--IDENT -> a [79:9]
+    |   `--SEMI -> ; [79:10]
+    |--VARIABLE_DEF -> VARIABLE_DEF [80:4]
+    |   |--MODIFIERS -> MODIFIERS [80:4]
+    |   |--TYPE -> TYPE [80:4]
+    |   |   `--LITERAL_CHAR -> char [80:4]
+    |   |--IDENT -> b [80:9]
+    |   |--ASSIGN -> = [80:11]
+    |   |   `--EXPR -> EXPR [80:13]
+    |   |       `--IDENT -> a [80:13]
+    |   `--SEMI -> ; [80:14]
+    |--VARIABLE_DEF -> VARIABLE_DEF [81:4]
+    |   |--MODIFIERS -> MODIFIERS [81:4]
+    |   |--TYPE -> TYPE [81:4]
+    |   |   `--LITERAL_BYTE -> byte [81:4]
+    |   |--IDENT -> c [81:9]
+    |   |--ASSIGN -> = [81:11]
+    |   |   `--EXPR -> EXPR [81:13]
+    |   |       `--NUM_INT -> 1 [81:13]
+    |   `--SEMI -> ; [81:14]
+    |--VARIABLE_DEF -> VARIABLE_DEF [82:4]
+    |   |--MODIFIERS -> MODIFIERS [82:4]
+    |   |--TYPE -> TYPE [82:4]
+    |   |   `--LITERAL_SHORT -> short [82:4]
+    |   |--IDENT -> d [82:10]
+    |   |--ASSIGN -> = [82:12]
+    |   |   `--EXPR -> EXPR [82:14]
+    |   |       `--NUM_INT -> 1 [82:14]
+    |   `--SEMI -> ; [82:15]
+    |--VARIABLE_DEF -> VARIABLE_DEF [83:4]
+    |   |--MODIFIERS -> MODIFIERS [83:4]
+    |   |   `--FINAL -> final [83:4]
+    |   |--TYPE -> TYPE [83:10]
+    |   |   `--LITERAL_LONG -> long [83:10]
+    |   |--IDENT -> e [83:15]
+    |   |--ASSIGN -> = [83:17]
+    |   |   `--EXPR -> EXPR [83:19]
+    |   |       `--NUM_INT -> 0 [83:19]
+    |   `--SEMI -> ; [83:20]
+    `--RCURLY -> } [84:0]
+CLASS_DEF -> CLASS_DEF [86:0]
+|--MODIFIERS -> MODIFIERS [86:0]
+|--LITERAL_CLASS -> class [86:0]
+|--IDENT -> Doubles [86:6]
+`--OBJBLOCK -> OBJBLOCK [86:14]
+    |--LCURLY -> { [86:14]
+    |--VARIABLE_DEF -> VARIABLE_DEF [87:4]
+    |   |--MODIFIERS -> MODIFIERS [87:4]
+    |   |   `--FINAL -> final [87:4]
+    |   |--TYPE -> TYPE [87:10]
+    |   |   `--LITERAL_DOUBLE -> double [87:10]
+    |   |--IDENT -> subZero [87:17]
+    |   |--ASSIGN -> = [87:25]
+    |   |   `--EXPR -> EXPR [87:27]
+    |   |       `--UNARY_MINUS -> - [87:27]
+    |   |           `--NUM_FLOAT -> 0.0 [87:28]
+    |   `--SEMI -> ; [87:31]
+    |--VARIABLE_DEF -> VARIABLE_DEF [88:4]
+    |   |--MODIFIERS -> MODIFIERS [88:4]
+    |   |   `--FINAL -> final [88:4]
+    |   |--TYPE -> TYPE [88:10]
+    |   |   `--LITERAL_DOUBLE -> double [88:10]
+    |   |--IDENT -> nan [88:17]
+    |   |--ASSIGN -> = [88:21]
+    |   |   `--EXPR -> EXPR [88:29]
+    |   |       `--DOT -> . [88:29]
+    |   |           |--IDENT -> Double [88:23]
+    |   |           `--IDENT -> NaN [88:30]
+    |   `--SEMI -> ; [88:33]
+    |--VARIABLE_DEF -> VARIABLE_DEF [89:4]
+    |   |--MODIFIERS -> MODIFIERS [89:4]
+    |   |   `--LITERAL_PRIVATE -> private [89:4]
+    |   |--TYPE -> TYPE [89:12]
+    |   |   `--LITERAL_SHORT -> short [89:12]
+    |   |--IDENT -> shortVariable [89:18]
+    |   |--ASSIGN -> = [89:32]
+    |   |   `--EXPR -> EXPR [89:34]
+    |   |       `--NUM_INT -> 0 [89:34]
+    |   `--SEMI -> ; [89:35]
+    |--VARIABLE_DEF -> VARIABLE_DEF [90:4]
+    |   |--MODIFIERS -> MODIFIERS [90:4]
+    |   |   `--LITERAL_PRIVATE -> private [90:4]
+    |   |--TYPE -> TYPE [90:12]
+    |   |   `--LITERAL_BYTE -> byte [90:12]
+    |   |--IDENT -> bite [90:17]
+    |   |--ASSIGN -> = [90:22]
+    |   |   `--EXPR -> EXPR [90:24]
+    |   |       `--NUM_INT -> 0 [90:24]
+    |   `--SEMI -> ; [90:25]
+    `--RCURLY -> } [91:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionExpressionList.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionExpressionList.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionExpressionList.java
@@ -0,0 +1,29 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+public class InputAntlr4AstRegressionExpressionList {
+        protected InputAntlr4AstRegressionExpressionList ( int i )
+    {
+        this (); //whitespace
+        toString ();
+    }
+    protected InputAntlr4AstRegressionExpressionList ()
+    {
+        super ();
+    }
+
+    public void enhancedFor ()
+    {
+        int[] i = new int[2];
+        for ( int j: i ) {
+            System.identityHashCode ( j );
+        }
+    }
+}
+
+@interface CronExpression {
+    Class<?>[] groups() default {};
+}
+
+@interface CronExpression1 {
+    Class<?>[] groups() default { }; // extra space
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionExpressionList.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionExpressionList.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionExpressionList.txt
@@ -0,0 +1,164 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+CLASS_DEF -> CLASS_DEF [3:0]
+|--MODIFIERS -> MODIFIERS [3:0]
+|   `--LITERAL_PUBLIC -> public [3:0]
+|--LITERAL_CLASS -> class [3:7]
+|--IDENT -> InputAntlr4AstRegressionExpressionList [3:13]
+`--OBJBLOCK -> OBJBLOCK [3:52]
+    |--LCURLY -> { [3:52]
+    |--CTOR_DEF -> CTOR_DEF [4:8]
+    |   |--MODIFIERS -> MODIFIERS [4:8]
+    |   |   `--LITERAL_PROTECTED -> protected [4:8]
+    |   |--IDENT -> InputAntlr4AstRegressionExpressionList [4:18]
+    |   |--LPAREN -> ( [4:57]
+    |   |--PARAMETERS -> PARAMETERS [4:59]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [4:59]
+    |   |       |--MODIFIERS -> MODIFIERS [4:59]
+    |   |       |--TYPE -> TYPE [4:59]
+    |   |       |   `--LITERAL_INT -> int [4:59]
+    |   |       `--IDENT -> i [4:63]
+    |   |--RPAREN -> ) [4:65]
+    |   `--SLIST -> { [5:4]
+    |       |--CTOR_CALL -> this [6:8]
+    |       |   |--LPAREN -> ( [6:13]
+    |       |   |--ELIST -> ELIST [6:14]
+    |       |   |--RPAREN -> ) [6:14]
+    |       |   `--SEMI -> ; [6:15]
+    |       |--EXPR -> EXPR [7:17]
+    |       |   `--METHOD_CALL -> ( [7:17]
+    |       |       |--IDENT -> toString [7:8]
+    |       |       |--ELIST -> ELIST [7:18]
+    |       |       `--RPAREN -> ) [7:18]
+    |       |--SEMI -> ; [7:19]
+    |       `--RCURLY -> } [8:4]
+    |--CTOR_DEF -> CTOR_DEF [9:4]
+    |   |--MODIFIERS -> MODIFIERS [9:4]
+    |   |   `--LITERAL_PROTECTED -> protected [9:4]
+    |   |--IDENT -> InputAntlr4AstRegressionExpressionList [9:14]
+    |   |--LPAREN -> ( [9:53]
+    |   |--PARAMETERS -> PARAMETERS [9:54]
+    |   |--RPAREN -> ) [9:54]
+    |   `--SLIST -> { [10:4]
+    |       |--SUPER_CTOR_CALL -> super [11:8]
+    |       |   |--LPAREN -> ( [11:14]
+    |       |   |--ELIST -> ELIST [11:15]
+    |       |   |--RPAREN -> ) [11:15]
+    |       |   `--SEMI -> ; [11:16]
+    |       `--RCURLY -> } [12:4]
+    |--METHOD_DEF -> METHOD_DEF [14:4]
+    |   |--MODIFIERS -> MODIFIERS [14:4]
+    |   |   `--LITERAL_PUBLIC -> public [14:4]
+    |   |--TYPE -> TYPE [14:11]
+    |   |   `--LITERAL_VOID -> void [14:11]
+    |   |--IDENT -> enhancedFor [14:16]
+    |   |--LPAREN -> ( [14:28]
+    |   |--PARAMETERS -> PARAMETERS [14:29]
+    |   |--RPAREN -> ) [14:29]
+    |   `--SLIST -> { [15:4]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [16:8]
+    |       |   |--MODIFIERS -> MODIFIERS [16:8]
+    |       |   |--TYPE -> TYPE [16:8]
+    |       |   |   |--LITERAL_INT -> int [16:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [16:11]
+    |       |   |       `--RBRACK -> ] [16:12]
+    |       |   |--IDENT -> i [16:14]
+    |       |   `--ASSIGN -> = [16:16]
+    |       |       `--EXPR -> EXPR [16:18]
+    |       |           `--LITERAL_NEW -> new [16:18]
+    |       |               |--LITERAL_INT -> int [16:22]
+    |       |               `--ARRAY_DECLARATOR -> [ [16:25]
+    |       |                   |--EXPR -> EXPR [16:26]
+    |       |                   |   `--NUM_INT -> 2 [16:26]
+    |       |                   `--RBRACK -> ] [16:27]
+    |       |--SEMI -> ; [16:28]
+    |       |--LITERAL_FOR -> for [17:8]
+    |       |   |--LPAREN -> ( [17:12]
+    |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [17:14]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [17:14]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [17:14]
+    |       |   |   |   |--TYPE -> TYPE [17:14]
+    |       |   |   |   |   `--LITERAL_INT -> int [17:14]
+    |       |   |   |   `--IDENT -> j [17:18]
+    |       |   |   |--COLON -> : [17:19]
+    |       |   |   `--EXPR -> EXPR [17:21]
+    |       |   |       `--IDENT -> i [17:21]
+    |       |   |--RPAREN -> ) [17:23]
+    |       |   `--SLIST -> { [17:25]
+    |       |       |--EXPR -> EXPR [18:36]
+    |       |       |   `--METHOD_CALL -> ( [18:36]
+    |       |       |       |--DOT -> . [18:18]
+    |       |       |       |   |--IDENT -> System [18:12]
+    |       |       |       |   `--IDENT -> identityHashCode [18:19]
+    |       |       |       |--ELIST -> ELIST [18:38]
+    |       |       |       |   `--EXPR -> EXPR [18:38]
+    |       |       |       |       `--IDENT -> j [18:38]
+    |       |       |       `--RPAREN -> ) [18:40]
+    |       |       |--SEMI -> ; [18:41]
+    |       |       `--RCURLY -> } [19:8]
+    |       `--RCURLY -> } [20:4]
+    `--RCURLY -> } [21:0]
+ANNOTATION_DEF -> ANNOTATION_DEF [23:0]
+|--MODIFIERS -> MODIFIERS [23:0]
+|--AT -> @ [23:0]
+|--LITERAL_INTERFACE -> interface [23:1]
+|--IDENT -> CronExpression [23:11]
+`--OBJBLOCK -> OBJBLOCK [23:26]
+    |--LCURLY -> { [23:26]
+    |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [24:4]
+    |   |--MODIFIERS -> MODIFIERS [24:4]
+    |   |--TYPE -> TYPE [24:4]
+    |   |   |--IDENT -> Class [24:4]
+    |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [24:9]
+    |   |   |   |--GENERIC_START -> < [24:9]
+    |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [24:10]
+    |   |   |   |   `--WILDCARD_TYPE -> ? [24:10]
+    |   |   |   `--GENERIC_END -> > [24:11]
+    |   |   `--ARRAY_DECLARATOR -> [ [24:12]
+    |   |       `--RBRACK -> ] [24:13]
+    |   |--IDENT -> groups [24:15]
+    |   |--LPAREN -> ( [24:21]
+    |   |--RPAREN -> ) [24:22]
+    |   |--LITERAL_DEFAULT -> default [24:24]
+    |   |   `--ANNOTATION_ARRAY_INIT -> { [24:32]
+    |   |       `--RCURLY -> } [24:33]
+    |   `--SEMI -> ; [24:34]
+    `--RCURLY -> } [25:0]
+ANNOTATION_DEF -> ANNOTATION_DEF [27:0]
+|--MODIFIERS -> MODIFIERS [27:0]
+|--AT -> @ [27:0]
+|--LITERAL_INTERFACE -> interface [27:1]
+|--IDENT -> CronExpression1 [27:11]
+`--OBJBLOCK -> OBJBLOCK [27:27]
+    |--LCURLY -> { [27:27]
+    |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [28:4]
+    |   |--MODIFIERS -> MODIFIERS [28:4]
+    |   |--TYPE -> TYPE [28:4]
+    |   |   |--IDENT -> Class [28:4]
+    |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [28:9]
+    |   |   |   |--GENERIC_START -> < [28:9]
+    |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [28:10]
+    |   |   |   |   `--WILDCARD_TYPE -> ? [28:10]
+    |   |   |   `--GENERIC_END -> > [28:11]
+    |   |   `--ARRAY_DECLARATOR -> [ [28:12]
+    |   |       `--RBRACK -> ] [28:13]
+    |   |--IDENT -> groups [28:15]
+    |   |--LPAREN -> ( [28:21]
+    |   |--RPAREN -> ) [28:22]
+    |   |--LITERAL_DEFAULT -> default [28:24]
+    |   |   `--ANNOTATION_ARRAY_INIT -> { [28:32]
+    |   |       `--RCURLY -> } [28:34]
+    |   `--SEMI -> ; [28:35]
+    `--RCURLY -> } [29:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionFallThroughDefault.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionFallThroughDefault.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionFallThroughDefault.java
@@ -0,0 +1,533 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+public class InputAntlr4AstRegressionFallThroughDefault {
+      void method(int i, int j, boolean cond) {
+        while (true) {
+            switch (i) {
+            case 0: // no problem
+            case 1:
+                i++;
+                break;
+            case 2:
+                i++;
+            case 3: //fall through!!!
+                i++;
+                break;
+            case 4:
+                return;
+            case 5:
+                throw new RuntimeException("");
+            case 6:
+                continue;
+            case 7: {
+                break;
+            }
+            case 8: {
+                return;
+            }
+            case 9: {
+                throw new RuntimeException("");
+            }
+            case 10: {
+                continue;
+            }
+            case 11: {
+                i++;
+            }
+            case 12: //fall through!!!
+                if (false)
+                    break;
+                else
+                    break;
+            case 13:
+                if (true) {
+                    return;
+                }
+            case 14:
+                if (true) {
+                    return;
+                } else {
+                    //do nothing
+                }
+            case 15: //fall through!!!
+                do {
+                    System.identityHashCode("something");
+                    return;
+                } while(true);
+            case 16:
+                for (int j1 = 0; j1 < 10; j1++) {
+                    String.valueOf("something");
+                    return;
+                }
+            case 17:
+                while (true)
+                    throw new RuntimeException("");
+            case 18:
+                while(cond) {
+                    break;
+                }
+            case 19: //fall through!!!
+                try {
+                    i++;
+                    break;
+                } catch (RuntimeException e) {
+                    break;
+                } catch (Error e) {
+                    return;
+                }
+            case 20:
+                try {
+                    i++;
+                    break;
+                } catch (RuntimeException e) {
+                } catch (Error e) {
+                    return;
+                }
+            case 21: //fall through!!!
+                try {
+                    i++;
+                } catch (RuntimeException e) {
+                    i--;
+                } finally {
+                    break;
+                }
+            case 22:
+                try {
+                    i++;
+                    break;
+                } catch (RuntimeException e) {
+                    i--;
+                    break;
+                } finally {
+                    i++;
+                }
+            case 23:
+                switch (j) {
+                case 1:
+                    continue;
+                case 2:
+                    return;
+                default:
+                    return;
+                }
+            case 24:
+                switch (j) {
+                case 1:
+                    continue;
+                case 2:
+                    break;
+                default:
+                    return;
+                }
+            default: //fall through!!!
+                // this is the last label
+                i++;
+            }
+        }
+    }
+
+
+
+    /* Like above, but all fall throughs with relief comment */
+    void methodFallThru(int i, int j, boolean cond) {
+      while (true) {
+          switch (i) {
+          case -1: // FALLTHRU
+
+          case 0: // no problem
+          case 1:
+              i++;
+              break;
+          case 2:
+              i++;
+              // fallthru
+          case 3:
+              i++;
+              break;
+          case 4:
+              return;
+          case 5:
+              throw new RuntimeException("");
+          case 6:
+              continue;
+          case 7: {
+              break;
+          }
+          case 8: {
+              return;
+          }
+          case 9: {
+              throw new RuntimeException("");
+          }
+          case 10: {
+              continue;
+          }
+          case 11: {
+              i++;
+          }
+          // fallthru
+          case 12:
+              if (false)
+                  break;
+              else
+                  break;
+          case 13:
+              if (true) {
+                  return;
+              }
+          case 14:
+              if (true) {
+                  return;
+              } else {
+                  //do nothing
+              }
+              // fallthru
+          case 15:
+              do {
+                  System.identityHashCode("something");
+                  return;
+              } while(true);
+          case 16:
+              for (int j1 = 0; j1 < 10; j1++) {
+                  String.valueOf("something");
+                  return;
+              }
+          case 17:
+              while (cond)
+                  throw new RuntimeException("");
+          case 18:
+              while(cond) {
+                  break;
+              }
+              // fallthru
+          case 19:
+              try {
+                  i++;
+                  break;
+              } catch (RuntimeException e) {
+                  break;
+              } catch (Error e) {
+                  return;
+              }
+          case 20:
+              try {
+                  i++;
+                  break;
+              } catch (RuntimeException e) {
+              } catch (Error e) {
+                  return;
+              }
+              // fallthru
+          case 21:
+              try {
+                  i++;
+              } catch (RuntimeException e) {
+                  i--;
+              } finally {
+                  break;
+              }
+          case 22:
+              try {
+                  i++;
+                  break;
+              } catch (RuntimeException e) {
+                  i--;
+                  break;
+              } finally {
+                  i++;
+              }
+
+          case 23:
+              switch (j) {
+              case 1:
+                  continue;
+              case 2:
+                  return;
+              default:
+                  return;
+              }
+          case 24:
+              i++;
+          /* fallthru */ case 25:
+              i++;
+              break;
+
+          case 26:
+              switch (j) {
+              case 1:
+                  continue;
+              case 2:
+                  break;
+              default:
+                  return;
+              }
+              // fallthru
+          default:
+              // this is the last label
+              i++;
+          // fallthru
+         }
+      }
+   }
+
+   /* Test relief comment. */
+   void methodFallThruCC(int i, int j, boolean cond) {
+      while (true) {
+          switch (i){
+          case 0:
+              i++; // fallthru
+
+          case 1:
+              i++;
+          // fallthru
+          case 2: {
+              i++;
+          }
+          // fallthru
+          case 3:
+              i++;
+          /* fallthru */case 4:
+                break;
+          case 5:
+              i++;
+          // fallthru
+          }
+      }
+   }
+
+   /* Like above, but C-style comments. */
+   void methodFallThruC(int i, int j, boolean cond) {
+      while (true) {
+          switch (i){
+          case 0:
+              i++; /* fallthru */
+
+          case 1:
+              i++;
+          /* fallthru */
+          case 2:
+              i++;
+          /* fallthru */case 3:
+                break;
+          case 4:
+              i++;
+          /* fallthru */
+          }
+      }
+   }
+
+   /* Like above, but C-style comments with no spaces. */
+   void methodFallThruC2(int i, int j, boolean cond) {
+      while (true) {
+          switch (i){
+          case 0:
+              i++; /*fallthru*/
+
+          case 1:
+              i++;
+          /*fallthru*/
+          case 2:
+              i++;
+          /*fallthru*/case 3:
+                break;
+          case 4:
+              i++;
+          /*fallthru*/
+          }
+      }
+   }
+
+   /* C-style comments with other default fallthru-comment. */
+   void methodFallThruCOtherWords(int i, int j, boolean cond) {
+      while (true) {
+          switch (i){
+          case 0:
+              i++; /* falls through */
+
+          case 1:
+              i++;
+          /* falls through */
+          case 2:
+              i++;
+          /* falls through */case 3:
+                break;
+          case 4:
+              i++;
+          /* falls through */
+          }
+      }
+   }
+
+   /* C-style comments with custom fallthru-comment. */
+   void methodFallThruCCustomWords(int i, int j, boolean cond) {
+      while (true) {
+          switch (i){
+          case 0:
+              i++; /* Continue with next case */
+
+          case 1:
+              i++;
+          /* Continue with next case */
+          case 2:
+              i++;
+          /* Continue with next case */case 3:
+                break;
+          case 4:
+              i++;
+          /* Continue with next case */
+          }
+      }
+   }
+
+   void methodFallThruLastCaseGroup(int i, int j, boolean cond) {
+       while (true) {
+           switch (i){
+           case 0:
+               i++; // fallthru
+           }
+           switch (i){
+           case 0:
+               i++;
+               // fallthru
+           }
+           switch (i){
+           case 0:
+               i++;
+           /* fallthru */ }
+       }
+    }
+
+    void method1472228(int i) {
+        switch(i) {
+        case 2:
+            // do nothing
+            break;
+        default:
+        }
+    }
+
+    void nestedSwitches() {
+        switch (hashCode()) {
+            case 1:
+                switch (hashCode()) { // causing NullPointerException in the past
+                    case 1:
+                }
+            default: // violation - no fall through comment
+        }
+    }
+
+    void nextedSwitches2() {
+        switch(hashCode()) {
+        case 1:
+            switch(hashCode()){}
+        case 2:
+            System.lineSeparator();
+            break;
+        }
+    }
+
+    void ifWithoutBreak() {
+        switch(hashCode()) {
+        case 1:
+            if (true) {
+                System.lineSeparator();
+            }
+        case 2:
+            System.lineSeparator();
+            break;
+        }
+    }
+
+    void noCommentAtTheEnd() {
+        switch(hashCode()) {
+        case 1: System.lineSeparator();
+
+        case 2:
+            System.lineSeparator();
+            break;
+        }
+    }
+
+    void synchronizedStatement() {
+       switch (hashCode()) {
+           case 1:
+               synchronized (this) {
+                   break;
+               }
+           case 2:
+               // synchronized nested in if
+               if (true) {
+                   synchronized (this) {
+                       break;
+                   }
+               } else {
+                   synchronized (this) {
+                       break;
+                   }
+               }
+           case 3:
+               synchronized (this) {
+               }
+               // fallthru
+           default:
+               break;
+       }
+    }
+
+    void multipleCasesOnOneLine() {
+        int i = 0;
+        switch (i) {
+        case 0: case 1: i *= i; // fall through
+        case 2: case 3: i *= i; // fall through
+        case 4: case 5: i *= i; // fall through
+        case 6: case 7: i *= i;
+            break;
+        default:
+            throw new RuntimeException();
+        }
+    }
+
+   /* Test relief comment. */
+   void methodFallThruWithDash(int i, int j, boolean cond) {
+      while (true) {
+          switch (i){
+              case 0:
+                  i++; // fallthru
+              case 1:
+                  i++; // fall thru
+              case 2:
+                  i++; // fall-thru
+              case 3:
+                  i++; // fallthrough
+              case 4:
+                  i++; // fall through
+              case 5:
+                  i++; // fall-through
+              case 6:
+                  i++; // fallsthru
+              case 7:
+                  i++; // falls thru
+              case 8:
+                  i++; // falls-thru
+              case 9:
+                  i++; // fallsthrough
+              case 10:
+                  i++; // falls through
+              case 11:
+                  i++; // falls-through
+              case 12:
+                  i++; // fall--through
+              case 13: //warn
+                  i++; // fall+through
+              case 14: //warn
+                  i++; // falls_thru
+              case 15: //warn
+                  i++; // falls=through
+              case 16: //warn
+                  i++; // falls-throug
+              default: //warn
+                  throw new RuntimeException();
+          }
+      }
+   }
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionFallThroughDefault.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionFallThroughDefault.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionFallThroughDefault.txt
@@ -0,0 +1,2340 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+CLASS_DEF -> CLASS_DEF [3:0]
+|--MODIFIERS -> MODIFIERS [3:0]
+|   `--LITERAL_PUBLIC -> public [3:0]
+|--LITERAL_CLASS -> class [3:7]
+|--IDENT -> InputAntlr4AstRegressionFallThroughDefault [3:13]
+`--OBJBLOCK -> OBJBLOCK [3:56]
+    |--LCURLY -> { [3:56]
+    |--METHOD_DEF -> METHOD_DEF [4:6]
+    |   |--MODIFIERS -> MODIFIERS [4:6]
+    |   |--TYPE -> TYPE [4:6]
+    |   |   `--LITERAL_VOID -> void [4:6]
+    |   |--IDENT -> method [4:11]
+    |   |--LPAREN -> ( [4:17]
+    |   |--PARAMETERS -> PARAMETERS [4:18]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [4:18]
+    |   |   |   |--MODIFIERS -> MODIFIERS [4:18]
+    |   |   |   |--TYPE -> TYPE [4:18]
+    |   |   |   |   `--LITERAL_INT -> int [4:18]
+    |   |   |   `--IDENT -> i [4:22]
+    |   |   |--COMMA -> , [4:23]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [4:25]
+    |   |   |   |--MODIFIERS -> MODIFIERS [4:25]
+    |   |   |   |--TYPE -> TYPE [4:25]
+    |   |   |   |   `--LITERAL_INT -> int [4:25]
+    |   |   |   `--IDENT -> j [4:29]
+    |   |   |--COMMA -> , [4:30]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [4:32]
+    |   |       |--MODIFIERS -> MODIFIERS [4:32]
+    |   |       |--TYPE -> TYPE [4:32]
+    |   |       |   `--LITERAL_BOOLEAN -> boolean [4:32]
+    |   |       `--IDENT -> cond [4:40]
+    |   |--RPAREN -> ) [4:44]
+    |   `--SLIST -> { [4:46]
+    |       |--LITERAL_WHILE -> while [5:8]
+    |       |   |--LPAREN -> ( [5:14]
+    |       |   |--EXPR -> EXPR [5:15]
+    |       |   |   `--LITERAL_TRUE -> true [5:15]
+    |       |   |--RPAREN -> ) [5:19]
+    |       |   `--SLIST -> { [5:21]
+    |       |       |--LITERAL_SWITCH -> switch [6:12]
+    |       |       |   |--LPAREN -> ( [6:19]
+    |       |       |   |--EXPR -> EXPR [6:20]
+    |       |       |   |   `--IDENT -> i [6:20]
+    |       |       |   |--RPAREN -> ) [6:21]
+    |       |       |   |--LCURLY -> { [6:23]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [7:12]
+    |       |       |   |   |--LITERAL_CASE -> case [7:12]
+    |       |       |   |   |   |--EXPR -> EXPR [7:17]
+    |       |       |   |   |   |   `--NUM_INT -> 0 [7:17]
+    |       |       |   |   |   `--COLON -> : [7:18]
+    |       |       |   |   |--LITERAL_CASE -> case [8:12]
+    |       |       |   |   |   |--EXPR -> EXPR [8:17]
+    |       |       |   |   |   |   `--NUM_INT -> 1 [8:17]
+    |       |       |   |   |   `--COLON -> : [8:18]
+    |       |       |   |   `--SLIST -> SLIST [9:17]
+    |       |       |   |       |--EXPR -> EXPR [9:17]
+    |       |       |   |       |   `--POST_INC -> ++ [9:17]
+    |       |       |   |       |       `--IDENT -> i [9:16]
+    |       |       |   |       |--SEMI -> ; [9:19]
+    |       |       |   |       `--LITERAL_BREAK -> break [10:16]
+    |       |       |   |           `--SEMI -> ; [10:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [11:12]
+    |       |       |   |   |--LITERAL_CASE -> case [11:12]
+    |       |       |   |   |   |--EXPR -> EXPR [11:17]
+    |       |       |   |   |   |   `--NUM_INT -> 2 [11:17]
+    |       |       |   |   |   `--COLON -> : [11:18]
+    |       |       |   |   `--SLIST -> SLIST [12:17]
+    |       |       |   |       |--EXPR -> EXPR [12:17]
+    |       |       |   |       |   `--POST_INC -> ++ [12:17]
+    |       |       |   |       |       `--IDENT -> i [12:16]
+    |       |       |   |       `--SEMI -> ; [12:19]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [13:12]
+    |       |       |   |   |--LITERAL_CASE -> case [13:12]
+    |       |       |   |   |   |--EXPR -> EXPR [13:17]
+    |       |       |   |   |   |   `--NUM_INT -> 3 [13:17]
+    |       |       |   |   |   `--COLON -> : [13:18]
+    |       |       |   |   `--SLIST -> SLIST [14:17]
+    |       |       |   |       |--EXPR -> EXPR [14:17]
+    |       |       |   |       |   `--POST_INC -> ++ [14:17]
+    |       |       |   |       |       `--IDENT -> i [14:16]
+    |       |       |   |       |--SEMI -> ; [14:19]
+    |       |       |   |       `--LITERAL_BREAK -> break [15:16]
+    |       |       |   |           `--SEMI -> ; [15:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [16:12]
+    |       |       |   |   |--LITERAL_CASE -> case [16:12]
+    |       |       |   |   |   |--EXPR -> EXPR [16:17]
+    |       |       |   |   |   |   `--NUM_INT -> 4 [16:17]
+    |       |       |   |   |   `--COLON -> : [16:18]
+    |       |       |   |   `--SLIST -> SLIST [17:16]
+    |       |       |   |       `--LITERAL_RETURN -> return [17:16]
+    |       |       |   |           `--SEMI -> ; [17:22]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [18:12]
+    |       |       |   |   |--LITERAL_CASE -> case [18:12]
+    |       |       |   |   |   |--EXPR -> EXPR [18:17]
+    |       |       |   |   |   |   `--NUM_INT -> 5 [18:17]
+    |       |       |   |   |   `--COLON -> : [18:18]
+    |       |       |   |   `--SLIST -> SLIST [19:16]
+    |       |       |   |       `--LITERAL_THROW -> throw [19:16]
+    |       |       |   |           |--EXPR -> EXPR [19:22]
+    |       |       |   |           |   `--LITERAL_NEW -> new [19:22]
+    |       |       |   |           |       |--IDENT -> RuntimeException [19:26]
+    |       |       |   |           |       |--LPAREN -> ( [19:42]
+    |       |       |   |           |       |--ELIST -> ELIST [19:43]
+    |       |       |   |           |       |   `--EXPR -> EXPR [19:43]
+    |       |       |   |           |       |       `--STRING_LITERAL -> "" [19:43]
+    |       |       |   |           |       `--RPAREN -> ) [19:45]
+    |       |       |   |           `--SEMI -> ; [19:46]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [20:12]
+    |       |       |   |   |--LITERAL_CASE -> case [20:12]
+    |       |       |   |   |   |--EXPR -> EXPR [20:17]
+    |       |       |   |   |   |   `--NUM_INT -> 6 [20:17]
+    |       |       |   |   |   `--COLON -> : [20:18]
+    |       |       |   |   `--SLIST -> SLIST [21:16]
+    |       |       |   |       `--LITERAL_CONTINUE -> continue [21:16]
+    |       |       |   |           `--SEMI -> ; [21:24]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [22:12]
+    |       |       |   |   |--LITERAL_CASE -> case [22:12]
+    |       |       |   |   |   |--EXPR -> EXPR [22:17]
+    |       |       |   |   |   |   `--NUM_INT -> 7 [22:17]
+    |       |       |   |   |   `--COLON -> : [22:18]
+    |       |       |   |   `--SLIST -> SLIST [22:20]
+    |       |       |   |       `--SLIST -> { [22:20]
+    |       |       |   |           |--LITERAL_BREAK -> break [23:16]
+    |       |       |   |           |   `--SEMI -> ; [23:21]
+    |       |       |   |           `--RCURLY -> } [24:12]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [25:12]
+    |       |       |   |   |--LITERAL_CASE -> case [25:12]
+    |       |       |   |   |   |--EXPR -> EXPR [25:17]
+    |       |       |   |   |   |   `--NUM_INT -> 8 [25:17]
+    |       |       |   |   |   `--COLON -> : [25:18]
+    |       |       |   |   `--SLIST -> SLIST [25:20]
+    |       |       |   |       `--SLIST -> { [25:20]
+    |       |       |   |           |--LITERAL_RETURN -> return [26:16]
+    |       |       |   |           |   `--SEMI -> ; [26:22]
+    |       |       |   |           `--RCURLY -> } [27:12]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [28:12]
+    |       |       |   |   |--LITERAL_CASE -> case [28:12]
+    |       |       |   |   |   |--EXPR -> EXPR [28:17]
+    |       |       |   |   |   |   `--NUM_INT -> 9 [28:17]
+    |       |       |   |   |   `--COLON -> : [28:18]
+    |       |       |   |   `--SLIST -> SLIST [28:20]
+    |       |       |   |       `--SLIST -> { [28:20]
+    |       |       |   |           |--LITERAL_THROW -> throw [29:16]
+    |       |       |   |           |   |--EXPR -> EXPR [29:22]
+    |       |       |   |           |   |   `--LITERAL_NEW -> new [29:22]
+    |       |       |   |           |   |       |--IDENT -> RuntimeException [29:26]
+    |       |       |   |           |   |       |--LPAREN -> ( [29:42]
+    |       |       |   |           |   |       |--ELIST -> ELIST [29:43]
+    |       |       |   |           |   |       |   `--EXPR -> EXPR [29:43]
+    |       |       |   |           |   |       |       `--STRING_LITERAL -> "" [29:43]
+    |       |       |   |           |   |       `--RPAREN -> ) [29:45]
+    |       |       |   |           |   `--SEMI -> ; [29:46]
+    |       |       |   |           `--RCURLY -> } [30:12]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [31:12]
+    |       |       |   |   |--LITERAL_CASE -> case [31:12]
+    |       |       |   |   |   |--EXPR -> EXPR [31:17]
+    |       |       |   |   |   |   `--NUM_INT -> 10 [31:17]
+    |       |       |   |   |   `--COLON -> : [31:19]
+    |       |       |   |   `--SLIST -> SLIST [31:21]
+    |       |       |   |       `--SLIST -> { [31:21]
+    |       |       |   |           |--LITERAL_CONTINUE -> continue [32:16]
+    |       |       |   |           |   `--SEMI -> ; [32:24]
+    |       |       |   |           `--RCURLY -> } [33:12]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [34:12]
+    |       |       |   |   |--LITERAL_CASE -> case [34:12]
+    |       |       |   |   |   |--EXPR -> EXPR [34:17]
+    |       |       |   |   |   |   `--NUM_INT -> 11 [34:17]
+    |       |       |   |   |   `--COLON -> : [34:19]
+    |       |       |   |   `--SLIST -> SLIST [34:21]
+    |       |       |   |       `--SLIST -> { [34:21]
+    |       |       |   |           |--EXPR -> EXPR [35:17]
+    |       |       |   |           |   `--POST_INC -> ++ [35:17]
+    |       |       |   |           |       `--IDENT -> i [35:16]
+    |       |       |   |           |--SEMI -> ; [35:19]
+    |       |       |   |           `--RCURLY -> } [36:12]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [37:12]
+    |       |       |   |   |--LITERAL_CASE -> case [37:12]
+    |       |       |   |   |   |--EXPR -> EXPR [37:17]
+    |       |       |   |   |   |   `--NUM_INT -> 12 [37:17]
+    |       |       |   |   |   `--COLON -> : [37:19]
+    |       |       |   |   `--SLIST -> SLIST [38:16]
+    |       |       |   |       `--LITERAL_IF -> if [38:16]
+    |       |       |   |           |--LPAREN -> ( [38:19]
+    |       |       |   |           |--EXPR -> EXPR [38:20]
+    |       |       |   |           |   `--LITERAL_FALSE -> false [38:20]
+    |       |       |   |           |--RPAREN -> ) [38:25]
+    |       |       |   |           |--LITERAL_BREAK -> break [39:20]
+    |       |       |   |           |   `--SEMI -> ; [39:25]
+    |       |       |   |           `--LITERAL_ELSE -> else [40:16]
+    |       |       |   |               `--LITERAL_BREAK -> break [41:20]
+    |       |       |   |                   `--SEMI -> ; [41:25]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [42:12]
+    |       |       |   |   |--LITERAL_CASE -> case [42:12]
+    |       |       |   |   |   |--EXPR -> EXPR [42:17]
+    |       |       |   |   |   |   `--NUM_INT -> 13 [42:17]
+    |       |       |   |   |   `--COLON -> : [42:19]
+    |       |       |   |   `--SLIST -> SLIST [43:16]
+    |       |       |   |       `--LITERAL_IF -> if [43:16]
+    |       |       |   |           |--LPAREN -> ( [43:19]
+    |       |       |   |           |--EXPR -> EXPR [43:20]
+    |       |       |   |           |   `--LITERAL_TRUE -> true [43:20]
+    |       |       |   |           |--RPAREN -> ) [43:24]
+    |       |       |   |           `--SLIST -> { [43:26]
+    |       |       |   |               |--LITERAL_RETURN -> return [44:20]
+    |       |       |   |               |   `--SEMI -> ; [44:26]
+    |       |       |   |               `--RCURLY -> } [45:16]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [46:12]
+    |       |       |   |   |--LITERAL_CASE -> case [46:12]
+    |       |       |   |   |   |--EXPR -> EXPR [46:17]
+    |       |       |   |   |   |   `--NUM_INT -> 14 [46:17]
+    |       |       |   |   |   `--COLON -> : [46:19]
+    |       |       |   |   `--SLIST -> SLIST [47:16]
+    |       |       |   |       `--LITERAL_IF -> if [47:16]
+    |       |       |   |           |--LPAREN -> ( [47:19]
+    |       |       |   |           |--EXPR -> EXPR [47:20]
+    |       |       |   |           |   `--LITERAL_TRUE -> true [47:20]
+    |       |       |   |           |--RPAREN -> ) [47:24]
+    |       |       |   |           |--SLIST -> { [47:26]
+    |       |       |   |           |   |--LITERAL_RETURN -> return [48:20]
+    |       |       |   |           |   |   `--SEMI -> ; [48:26]
+    |       |       |   |           |   `--RCURLY -> } [49:16]
+    |       |       |   |           `--LITERAL_ELSE -> else [49:18]
+    |       |       |   |               `--SLIST -> { [49:23]
+    |       |       |   |                   `--RCURLY -> } [51:16]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [52:12]
+    |       |       |   |   |--LITERAL_CASE -> case [52:12]
+    |       |       |   |   |   |--EXPR -> EXPR [52:17]
+    |       |       |   |   |   |   `--NUM_INT -> 15 [52:17]
+    |       |       |   |   |   `--COLON -> : [52:19]
+    |       |       |   |   `--SLIST -> SLIST [53:16]
+    |       |       |   |       `--LITERAL_DO -> do [53:16]
+    |       |       |   |           |--SLIST -> { [53:19]
+    |       |       |   |           |   |--EXPR -> EXPR [54:43]
+    |       |       |   |           |   |   `--METHOD_CALL -> ( [54:43]
+    |       |       |   |           |   |       |--DOT -> . [54:26]
+    |       |       |   |           |   |       |   |--IDENT -> System [54:20]
+    |       |       |   |           |   |       |   `--IDENT -> identityHashCode [54:27]
+    |       |       |   |           |   |       |--ELIST -> ELIST [54:44]
+    |       |       |   |           |   |       |   `--EXPR -> EXPR [54:44]
+    |       |       |   |           |   |       |       `--STRING_LITERAL -> "something" [54:44]
+    |       |       |   |           |   |       `--RPAREN -> ) [54:55]
+    |       |       |   |           |   |--SEMI -> ; [54:56]
+    |       |       |   |           |   |--LITERAL_RETURN -> return [55:20]
+    |       |       |   |           |   |   `--SEMI -> ; [55:26]
+    |       |       |   |           |   `--RCURLY -> } [56:16]
+    |       |       |   |           |--DO_WHILE -> while [56:18]
+    |       |       |   |           |--LPAREN -> ( [56:23]
+    |       |       |   |           |--EXPR -> EXPR [56:24]
+    |       |       |   |           |   `--LITERAL_TRUE -> true [56:24]
+    |       |       |   |           |--RPAREN -> ) [56:28]
+    |       |       |   |           `--SEMI -> ; [56:29]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [57:12]
+    |       |       |   |   |--LITERAL_CASE -> case [57:12]
+    |       |       |   |   |   |--EXPR -> EXPR [57:17]
+    |       |       |   |   |   |   `--NUM_INT -> 16 [57:17]
+    |       |       |   |   |   `--COLON -> : [57:19]
+    |       |       |   |   `--SLIST -> SLIST [58:16]
+    |       |       |   |       `--LITERAL_FOR -> for [58:16]
+    |       |       |   |           |--LPAREN -> ( [58:20]
+    |       |       |   |           |--FOR_INIT -> FOR_INIT [58:21]
+    |       |       |   |           |   `--VARIABLE_DEF -> VARIABLE_DEF [58:21]
+    |       |       |   |           |       |--MODIFIERS -> MODIFIERS [58:21]
+    |       |       |   |           |       |--TYPE -> TYPE [58:21]
+    |       |       |   |           |       |   `--LITERAL_INT -> int [58:21]
+    |       |       |   |           |       |--IDENT -> j1 [58:25]
+    |       |       |   |           |       `--ASSIGN -> = [58:28]
+    |       |       |   |           |           `--EXPR -> EXPR [58:30]
+    |       |       |   |           |               `--NUM_INT -> 0 [58:30]
+    |       |       |   |           |--SEMI -> ; [58:31]
+    |       |       |   |           |--FOR_CONDITION -> FOR_CONDITION [58:36]
+    |       |       |   |           |   `--EXPR -> EXPR [58:36]
+    |       |       |   |           |       `--LT -> < [58:36]
+    |       |       |   |           |           |--IDENT -> j1 [58:33]
+    |       |       |   |           |           `--NUM_INT -> 10 [58:38]
+    |       |       |   |           |--SEMI -> ; [58:40]
+    |       |       |   |           |--FOR_ITERATOR -> FOR_ITERATOR [58:44]
+    |       |       |   |           |   `--ELIST -> ELIST [58:44]
+    |       |       |   |           |       `--EXPR -> EXPR [58:44]
+    |       |       |   |           |           `--POST_INC -> ++ [58:44]
+    |       |       |   |           |               `--IDENT -> j1 [58:42]
+    |       |       |   |           |--RPAREN -> ) [58:46]
+    |       |       |   |           `--SLIST -> { [58:48]
+    |       |       |   |               |--EXPR -> EXPR [59:34]
+    |       |       |   |               |   `--METHOD_CALL -> ( [59:34]
+    |       |       |   |               |       |--DOT -> . [59:26]
+    |       |       |   |               |       |   |--IDENT -> String [59:20]
+    |       |       |   |               |       |   `--IDENT -> valueOf [59:27]
+    |       |       |   |               |       |--ELIST -> ELIST [59:35]
+    |       |       |   |               |       |   `--EXPR -> EXPR [59:35]
+    |       |       |   |               |       |       `--STRING_LITERAL -> "something" [59:35]
+    |       |       |   |               |       `--RPAREN -> ) [59:46]
+    |       |       |   |               |--SEMI -> ; [59:47]
+    |       |       |   |               |--LITERAL_RETURN -> return [60:20]
+    |       |       |   |               |   `--SEMI -> ; [60:26]
+    |       |       |   |               `--RCURLY -> } [61:16]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [62:12]
+    |       |       |   |   |--LITERAL_CASE -> case [62:12]
+    |       |       |   |   |   |--EXPR -> EXPR [62:17]
+    |       |       |   |   |   |   `--NUM_INT -> 17 [62:17]
+    |       |       |   |   |   `--COLON -> : [62:19]
+    |       |       |   |   `--SLIST -> SLIST [63:16]
+    |       |       |   |       `--LITERAL_WHILE -> while [63:16]
+    |       |       |   |           |--LPAREN -> ( [63:22]
+    |       |       |   |           |--EXPR -> EXPR [63:23]
+    |       |       |   |           |   `--LITERAL_TRUE -> true [63:23]
+    |       |       |   |           |--RPAREN -> ) [63:27]
+    |       |       |   |           `--LITERAL_THROW -> throw [64:20]
+    |       |       |   |               |--EXPR -> EXPR [64:26]
+    |       |       |   |               |   `--LITERAL_NEW -> new [64:26]
+    |       |       |   |               |       |--IDENT -> RuntimeException [64:30]
+    |       |       |   |               |       |--LPAREN -> ( [64:46]
+    |       |       |   |               |       |--ELIST -> ELIST [64:47]
+    |       |       |   |               |       |   `--EXPR -> EXPR [64:47]
+    |       |       |   |               |       |       `--STRING_LITERAL -> "" [64:47]
+    |       |       |   |               |       `--RPAREN -> ) [64:49]
+    |       |       |   |               `--SEMI -> ; [64:50]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [65:12]
+    |       |       |   |   |--LITERAL_CASE -> case [65:12]
+    |       |       |   |   |   |--EXPR -> EXPR [65:17]
+    |       |       |   |   |   |   `--NUM_INT -> 18 [65:17]
+    |       |       |   |   |   `--COLON -> : [65:19]
+    |       |       |   |   `--SLIST -> SLIST [66:16]
+    |       |       |   |       `--LITERAL_WHILE -> while [66:16]
+    |       |       |   |           |--LPAREN -> ( [66:21]
+    |       |       |   |           |--EXPR -> EXPR [66:22]
+    |       |       |   |           |   `--IDENT -> cond [66:22]
+    |       |       |   |           |--RPAREN -> ) [66:26]
+    |       |       |   |           `--SLIST -> { [66:28]
+    |       |       |   |               |--LITERAL_BREAK -> break [67:20]
+    |       |       |   |               |   `--SEMI -> ; [67:25]
+    |       |       |   |               `--RCURLY -> } [68:16]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [69:12]
+    |       |       |   |   |--LITERAL_CASE -> case [69:12]
+    |       |       |   |   |   |--EXPR -> EXPR [69:17]
+    |       |       |   |   |   |   `--NUM_INT -> 19 [69:17]
+    |       |       |   |   |   `--COLON -> : [69:19]
+    |       |       |   |   `--SLIST -> SLIST [70:16]
+    |       |       |   |       `--LITERAL_TRY -> try [70:16]
+    |       |       |   |           |--SLIST -> { [70:20]
+    |       |       |   |           |   |--EXPR -> EXPR [71:21]
+    |       |       |   |           |   |   `--POST_INC -> ++ [71:21]
+    |       |       |   |           |   |       `--IDENT -> i [71:20]
+    |       |       |   |           |   |--SEMI -> ; [71:23]
+    |       |       |   |           |   |--LITERAL_BREAK -> break [72:20]
+    |       |       |   |           |   |   `--SEMI -> ; [72:25]
+    |       |       |   |           |   `--RCURLY -> } [73:16]
+    |       |       |   |           |--LITERAL_CATCH -> catch [73:18]
+    |       |       |   |           |   |--LPAREN -> ( [73:24]
+    |       |       |   |           |   |--PARAMETER_DEF -> PARAMETER_DEF [73:25]
+    |       |       |   |           |   |   |--MODIFIERS -> MODIFIERS [73:25]
+    |       |       |   |           |   |   |--TYPE -> TYPE [73:25]
+    |       |       |   |           |   |   |   `--IDENT -> RuntimeException [73:25]
+    |       |       |   |           |   |   `--IDENT -> e [73:42]
+    |       |       |   |           |   |--RPAREN -> ) [73:43]
+    |       |       |   |           |   `--SLIST -> { [73:45]
+    |       |       |   |           |       |--LITERAL_BREAK -> break [74:20]
+    |       |       |   |           |       |   `--SEMI -> ; [74:25]
+    |       |       |   |           |       `--RCURLY -> } [75:16]
+    |       |       |   |           `--LITERAL_CATCH -> catch [75:18]
+    |       |       |   |               |--LPAREN -> ( [75:24]
+    |       |       |   |               |--PARAMETER_DEF -> PARAMETER_DEF [75:25]
+    |       |       |   |               |   |--MODIFIERS -> MODIFIERS [75:25]
+    |       |       |   |               |   |--TYPE -> TYPE [75:25]
+    |       |       |   |               |   |   `--IDENT -> Error [75:25]
+    |       |       |   |               |   `--IDENT -> e [75:31]
+    |       |       |   |               |--RPAREN -> ) [75:32]
+    |       |       |   |               `--SLIST -> { [75:34]
+    |       |       |   |                   |--LITERAL_RETURN -> return [76:20]
+    |       |       |   |                   |   `--SEMI -> ; [76:26]
+    |       |       |   |                   `--RCURLY -> } [77:16]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [78:12]
+    |       |       |   |   |--LITERAL_CASE -> case [78:12]
+    |       |       |   |   |   |--EXPR -> EXPR [78:17]
+    |       |       |   |   |   |   `--NUM_INT -> 20 [78:17]
+    |       |       |   |   |   `--COLON -> : [78:19]
+    |       |       |   |   `--SLIST -> SLIST [79:16]
+    |       |       |   |       `--LITERAL_TRY -> try [79:16]
+    |       |       |   |           |--SLIST -> { [79:20]
+    |       |       |   |           |   |--EXPR -> EXPR [80:21]
+    |       |       |   |           |   |   `--POST_INC -> ++ [80:21]
+    |       |       |   |           |   |       `--IDENT -> i [80:20]
+    |       |       |   |           |   |--SEMI -> ; [80:23]
+    |       |       |   |           |   |--LITERAL_BREAK -> break [81:20]
+    |       |       |   |           |   |   `--SEMI -> ; [81:25]
+    |       |       |   |           |   `--RCURLY -> } [82:16]
+    |       |       |   |           |--LITERAL_CATCH -> catch [82:18]
+    |       |       |   |           |   |--LPAREN -> ( [82:24]
+    |       |       |   |           |   |--PARAMETER_DEF -> PARAMETER_DEF [82:25]
+    |       |       |   |           |   |   |--MODIFIERS -> MODIFIERS [82:25]
+    |       |       |   |           |   |   |--TYPE -> TYPE [82:25]
+    |       |       |   |           |   |   |   `--IDENT -> RuntimeException [82:25]
+    |       |       |   |           |   |   `--IDENT -> e [82:42]
+    |       |       |   |           |   |--RPAREN -> ) [82:43]
+    |       |       |   |           |   `--SLIST -> { [82:45]
+    |       |       |   |           |       `--RCURLY -> } [83:16]
+    |       |       |   |           `--LITERAL_CATCH -> catch [83:18]
+    |       |       |   |               |--LPAREN -> ( [83:24]
+    |       |       |   |               |--PARAMETER_DEF -> PARAMETER_DEF [83:25]
+    |       |       |   |               |   |--MODIFIERS -> MODIFIERS [83:25]
+    |       |       |   |               |   |--TYPE -> TYPE [83:25]
+    |       |       |   |               |   |   `--IDENT -> Error [83:25]
+    |       |       |   |               |   `--IDENT -> e [83:31]
+    |       |       |   |               |--RPAREN -> ) [83:32]
+    |       |       |   |               `--SLIST -> { [83:34]
+    |       |       |   |                   |--LITERAL_RETURN -> return [84:20]
+    |       |       |   |                   |   `--SEMI -> ; [84:26]
+    |       |       |   |                   `--RCURLY -> } [85:16]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [86:12]
+    |       |       |   |   |--LITERAL_CASE -> case [86:12]
+    |       |       |   |   |   |--EXPR -> EXPR [86:17]
+    |       |       |   |   |   |   `--NUM_INT -> 21 [86:17]
+    |       |       |   |   |   `--COLON -> : [86:19]
+    |       |       |   |   `--SLIST -> SLIST [87:16]
+    |       |       |   |       `--LITERAL_TRY -> try [87:16]
+    |       |       |   |           |--SLIST -> { [87:20]
+    |       |       |   |           |   |--EXPR -> EXPR [88:21]
+    |       |       |   |           |   |   `--POST_INC -> ++ [88:21]
+    |       |       |   |           |   |       `--IDENT -> i [88:20]
+    |       |       |   |           |   |--SEMI -> ; [88:23]
+    |       |       |   |           |   `--RCURLY -> } [89:16]
+    |       |       |   |           |--LITERAL_CATCH -> catch [89:18]
+    |       |       |   |           |   |--LPAREN -> ( [89:24]
+    |       |       |   |           |   |--PARAMETER_DEF -> PARAMETER_DEF [89:25]
+    |       |       |   |           |   |   |--MODIFIERS -> MODIFIERS [89:25]
+    |       |       |   |           |   |   |--TYPE -> TYPE [89:25]
+    |       |       |   |           |   |   |   `--IDENT -> RuntimeException [89:25]
+    |       |       |   |           |   |   `--IDENT -> e [89:42]
+    |       |       |   |           |   |--RPAREN -> ) [89:43]
+    |       |       |   |           |   `--SLIST -> { [89:45]
+    |       |       |   |           |       |--EXPR -> EXPR [90:21]
+    |       |       |   |           |       |   `--POST_DEC -> -- [90:21]
+    |       |       |   |           |       |       `--IDENT -> i [90:20]
+    |       |       |   |           |       |--SEMI -> ; [90:23]
+    |       |       |   |           |       `--RCURLY -> } [91:16]
+    |       |       |   |           `--LITERAL_FINALLY -> finally [91:18]
+    |       |       |   |               `--SLIST -> { [91:26]
+    |       |       |   |                   |--LITERAL_BREAK -> break [92:20]
+    |       |       |   |                   |   `--SEMI -> ; [92:25]
+    |       |       |   |                   `--RCURLY -> } [93:16]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [94:12]
+    |       |       |   |   |--LITERAL_CASE -> case [94:12]
+    |       |       |   |   |   |--EXPR -> EXPR [94:17]
+    |       |       |   |   |   |   `--NUM_INT -> 22 [94:17]
+    |       |       |   |   |   `--COLON -> : [94:19]
+    |       |       |   |   `--SLIST -> SLIST [95:16]
+    |       |       |   |       `--LITERAL_TRY -> try [95:16]
+    |       |       |   |           |--SLIST -> { [95:20]
+    |       |       |   |           |   |--EXPR -> EXPR [96:21]
+    |       |       |   |           |   |   `--POST_INC -> ++ [96:21]
+    |       |       |   |           |   |       `--IDENT -> i [96:20]
+    |       |       |   |           |   |--SEMI -> ; [96:23]
+    |       |       |   |           |   |--LITERAL_BREAK -> break [97:20]
+    |       |       |   |           |   |   `--SEMI -> ; [97:25]
+    |       |       |   |           |   `--RCURLY -> } [98:16]
+    |       |       |   |           |--LITERAL_CATCH -> catch [98:18]
+    |       |       |   |           |   |--LPAREN -> ( [98:24]
+    |       |       |   |           |   |--PARAMETER_DEF -> PARAMETER_DEF [98:25]
+    |       |       |   |           |   |   |--MODIFIERS -> MODIFIERS [98:25]
+    |       |       |   |           |   |   |--TYPE -> TYPE [98:25]
+    |       |       |   |           |   |   |   `--IDENT -> RuntimeException [98:25]
+    |       |       |   |           |   |   `--IDENT -> e [98:42]
+    |       |       |   |           |   |--RPAREN -> ) [98:43]
+    |       |       |   |           |   `--SLIST -> { [98:45]
+    |       |       |   |           |       |--EXPR -> EXPR [99:21]
+    |       |       |   |           |       |   `--POST_DEC -> -- [99:21]
+    |       |       |   |           |       |       `--IDENT -> i [99:20]
+    |       |       |   |           |       |--SEMI -> ; [99:23]
+    |       |       |   |           |       |--LITERAL_BREAK -> break [100:20]
+    |       |       |   |           |       |   `--SEMI -> ; [100:25]
+    |       |       |   |           |       `--RCURLY -> } [101:16]
+    |       |       |   |           `--LITERAL_FINALLY -> finally [101:18]
+    |       |       |   |               `--SLIST -> { [101:26]
+    |       |       |   |                   |--EXPR -> EXPR [102:21]
+    |       |       |   |                   |   `--POST_INC -> ++ [102:21]
+    |       |       |   |                   |       `--IDENT -> i [102:20]
+    |       |       |   |                   |--SEMI -> ; [102:23]
+    |       |       |   |                   `--RCURLY -> } [103:16]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [104:12]
+    |       |       |   |   |--LITERAL_CASE -> case [104:12]
+    |       |       |   |   |   |--EXPR -> EXPR [104:17]
+    |       |       |   |   |   |   `--NUM_INT -> 23 [104:17]
+    |       |       |   |   |   `--COLON -> : [104:19]
+    |       |       |   |   `--SLIST -> SLIST [105:16]
+    |       |       |   |       `--LITERAL_SWITCH -> switch [105:16]
+    |       |       |   |           |--LPAREN -> ( [105:23]
+    |       |       |   |           |--EXPR -> EXPR [105:24]
+    |       |       |   |           |   `--IDENT -> j [105:24]
+    |       |       |   |           |--RPAREN -> ) [105:25]
+    |       |       |   |           |--LCURLY -> { [105:27]
+    |       |       |   |           |--CASE_GROUP -> CASE_GROUP [106:16]
+    |       |       |   |           |   |--LITERAL_CASE -> case [106:16]
+    |       |       |   |           |   |   |--EXPR -> EXPR [106:21]
+    |       |       |   |           |   |   |   `--NUM_INT -> 1 [106:21]
+    |       |       |   |           |   |   `--COLON -> : [106:22]
+    |       |       |   |           |   `--SLIST -> SLIST [107:20]
+    |       |       |   |           |       `--LITERAL_CONTINUE -> continue [107:20]
+    |       |       |   |           |           `--SEMI -> ; [107:28]
+    |       |       |   |           |--CASE_GROUP -> CASE_GROUP [108:16]
+    |       |       |   |           |   |--LITERAL_CASE -> case [108:16]
+    |       |       |   |           |   |   |--EXPR -> EXPR [108:21]
+    |       |       |   |           |   |   |   `--NUM_INT -> 2 [108:21]
+    |       |       |   |           |   |   `--COLON -> : [108:22]
+    |       |       |   |           |   `--SLIST -> SLIST [109:20]
+    |       |       |   |           |       `--LITERAL_RETURN -> return [109:20]
+    |       |       |   |           |           `--SEMI -> ; [109:26]
+    |       |       |   |           |--CASE_GROUP -> CASE_GROUP [110:16]
+    |       |       |   |           |   |--LITERAL_DEFAULT -> default [110:16]
+    |       |       |   |           |   |   `--COLON -> : [110:23]
+    |       |       |   |           |   `--SLIST -> SLIST [111:20]
+    |       |       |   |           |       `--LITERAL_RETURN -> return [111:20]
+    |       |       |   |           |           `--SEMI -> ; [111:26]
+    |       |       |   |           `--RCURLY -> } [112:16]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [113:12]
+    |       |       |   |   |--LITERAL_CASE -> case [113:12]
+    |       |       |   |   |   |--EXPR -> EXPR [113:17]
+    |       |       |   |   |   |   `--NUM_INT -> 24 [113:17]
+    |       |       |   |   |   `--COLON -> : [113:19]
+    |       |       |   |   `--SLIST -> SLIST [114:16]
+    |       |       |   |       `--LITERAL_SWITCH -> switch [114:16]
+    |       |       |   |           |--LPAREN -> ( [114:23]
+    |       |       |   |           |--EXPR -> EXPR [114:24]
+    |       |       |   |           |   `--IDENT -> j [114:24]
+    |       |       |   |           |--RPAREN -> ) [114:25]
+    |       |       |   |           |--LCURLY -> { [114:27]
+    |       |       |   |           |--CASE_GROUP -> CASE_GROUP [115:16]
+    |       |       |   |           |   |--LITERAL_CASE -> case [115:16]
+    |       |       |   |           |   |   |--EXPR -> EXPR [115:21]
+    |       |       |   |           |   |   |   `--NUM_INT -> 1 [115:21]
+    |       |       |   |           |   |   `--COLON -> : [115:22]
+    |       |       |   |           |   `--SLIST -> SLIST [116:20]
+    |       |       |   |           |       `--LITERAL_CONTINUE -> continue [116:20]
+    |       |       |   |           |           `--SEMI -> ; [116:28]
+    |       |       |   |           |--CASE_GROUP -> CASE_GROUP [117:16]
+    |       |       |   |           |   |--LITERAL_CASE -> case [117:16]
+    |       |       |   |           |   |   |--EXPR -> EXPR [117:21]
+    |       |       |   |           |   |   |   `--NUM_INT -> 2 [117:21]
+    |       |       |   |           |   |   `--COLON -> : [117:22]
+    |       |       |   |           |   `--SLIST -> SLIST [118:20]
+    |       |       |   |           |       `--LITERAL_BREAK -> break [118:20]
+    |       |       |   |           |           `--SEMI -> ; [118:25]
+    |       |       |   |           |--CASE_GROUP -> CASE_GROUP [119:16]
+    |       |       |   |           |   |--LITERAL_DEFAULT -> default [119:16]
+    |       |       |   |           |   |   `--COLON -> : [119:23]
+    |       |       |   |           |   `--SLIST -> SLIST [120:20]
+    |       |       |   |           |       `--LITERAL_RETURN -> return [120:20]
+    |       |       |   |           |           `--SEMI -> ; [120:26]
+    |       |       |   |           `--RCURLY -> } [121:16]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [122:12]
+    |       |       |   |   |--LITERAL_DEFAULT -> default [122:12]
+    |       |       |   |   |   `--COLON -> : [122:19]
+    |       |       |   |   `--SLIST -> SLIST [124:17]
+    |       |       |   |       |--EXPR -> EXPR [124:17]
+    |       |       |   |       |   `--POST_INC -> ++ [124:17]
+    |       |       |   |       |       `--IDENT -> i [124:16]
+    |       |       |   |       `--SEMI -> ; [124:19]
+    |       |       |   `--RCURLY -> } [125:12]
+    |       |       `--RCURLY -> } [126:8]
+    |       `--RCURLY -> } [127:4]
+    |--METHOD_DEF -> METHOD_DEF [132:4]
+    |   |--MODIFIERS -> MODIFIERS [132:4]
+    |   |--TYPE -> TYPE [132:4]
+    |   |   `--LITERAL_VOID -> void [132:4]
+    |   |--IDENT -> methodFallThru [132:9]
+    |   |--LPAREN -> ( [132:23]
+    |   |--PARAMETERS -> PARAMETERS [132:24]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [132:24]
+    |   |   |   |--MODIFIERS -> MODIFIERS [132:24]
+    |   |   |   |--TYPE -> TYPE [132:24]
+    |   |   |   |   `--LITERAL_INT -> int [132:24]
+    |   |   |   `--IDENT -> i [132:28]
+    |   |   |--COMMA -> , [132:29]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [132:31]
+    |   |   |   |--MODIFIERS -> MODIFIERS [132:31]
+    |   |   |   |--TYPE -> TYPE [132:31]
+    |   |   |   |   `--LITERAL_INT -> int [132:31]
+    |   |   |   `--IDENT -> j [132:35]
+    |   |   |--COMMA -> , [132:36]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [132:38]
+    |   |       |--MODIFIERS -> MODIFIERS [132:38]
+    |   |       |--TYPE -> TYPE [132:38]
+    |   |       |   `--LITERAL_BOOLEAN -> boolean [132:38]
+    |   |       `--IDENT -> cond [132:46]
+    |   |--RPAREN -> ) [132:50]
+    |   `--SLIST -> { [132:52]
+    |       |--LITERAL_WHILE -> while [133:6]
+    |       |   |--LPAREN -> ( [133:12]
+    |       |   |--EXPR -> EXPR [133:13]
+    |       |   |   `--LITERAL_TRUE -> true [133:13]
+    |       |   |--RPAREN -> ) [133:17]
+    |       |   `--SLIST -> { [133:19]
+    |       |       |--LITERAL_SWITCH -> switch [134:10]
+    |       |       |   |--LPAREN -> ( [134:17]
+    |       |       |   |--EXPR -> EXPR [134:18]
+    |       |       |   |   `--IDENT -> i [134:18]
+    |       |       |   |--RPAREN -> ) [134:19]
+    |       |       |   |--LCURLY -> { [134:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [135:10]
+    |       |       |   |   |--LITERAL_CASE -> case [135:10]
+    |       |       |   |   |   |--EXPR -> EXPR [135:15]
+    |       |       |   |   |   |   `--UNARY_MINUS -> - [135:15]
+    |       |       |   |   |   |       `--NUM_INT -> 1 [135:16]
+    |       |       |   |   |   `--COLON -> : [135:17]
+    |       |       |   |   |--LITERAL_CASE -> case [137:10]
+    |       |       |   |   |   |--EXPR -> EXPR [137:15]
+    |       |       |   |   |   |   `--NUM_INT -> 0 [137:15]
+    |       |       |   |   |   `--COLON -> : [137:16]
+    |       |       |   |   |--LITERAL_CASE -> case [138:10]
+    |       |       |   |   |   |--EXPR -> EXPR [138:15]
+    |       |       |   |   |   |   `--NUM_INT -> 1 [138:15]
+    |       |       |   |   |   `--COLON -> : [138:16]
+    |       |       |   |   `--SLIST -> SLIST [139:15]
+    |       |       |   |       |--EXPR -> EXPR [139:15]
+    |       |       |   |       |   `--POST_INC -> ++ [139:15]
+    |       |       |   |       |       `--IDENT -> i [139:14]
+    |       |       |   |       |--SEMI -> ; [139:17]
+    |       |       |   |       `--LITERAL_BREAK -> break [140:14]
+    |       |       |   |           `--SEMI -> ; [140:19]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [141:10]
+    |       |       |   |   |--LITERAL_CASE -> case [141:10]
+    |       |       |   |   |   |--EXPR -> EXPR [141:15]
+    |       |       |   |   |   |   `--NUM_INT -> 2 [141:15]
+    |       |       |   |   |   `--COLON -> : [141:16]
+    |       |       |   |   `--SLIST -> SLIST [142:15]
+    |       |       |   |       |--EXPR -> EXPR [142:15]
+    |       |       |   |       |   `--POST_INC -> ++ [142:15]
+    |       |       |   |       |       `--IDENT -> i [142:14]
+    |       |       |   |       `--SEMI -> ; [142:17]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [144:10]
+    |       |       |   |   |--LITERAL_CASE -> case [144:10]
+    |       |       |   |   |   |--EXPR -> EXPR [144:15]
+    |       |       |   |   |   |   `--NUM_INT -> 3 [144:15]
+    |       |       |   |   |   `--COLON -> : [144:16]
+    |       |       |   |   `--SLIST -> SLIST [145:15]
+    |       |       |   |       |--EXPR -> EXPR [145:15]
+    |       |       |   |       |   `--POST_INC -> ++ [145:15]
+    |       |       |   |       |       `--IDENT -> i [145:14]
+    |       |       |   |       |--SEMI -> ; [145:17]
+    |       |       |   |       `--LITERAL_BREAK -> break [146:14]
+    |       |       |   |           `--SEMI -> ; [146:19]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [147:10]
+    |       |       |   |   |--LITERAL_CASE -> case [147:10]
+    |       |       |   |   |   |--EXPR -> EXPR [147:15]
+    |       |       |   |   |   |   `--NUM_INT -> 4 [147:15]
+    |       |       |   |   |   `--COLON -> : [147:16]
+    |       |       |   |   `--SLIST -> SLIST [148:14]
+    |       |       |   |       `--LITERAL_RETURN -> return [148:14]
+    |       |       |   |           `--SEMI -> ; [148:20]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [149:10]
+    |       |       |   |   |--LITERAL_CASE -> case [149:10]
+    |       |       |   |   |   |--EXPR -> EXPR [149:15]
+    |       |       |   |   |   |   `--NUM_INT -> 5 [149:15]
+    |       |       |   |   |   `--COLON -> : [149:16]
+    |       |       |   |   `--SLIST -> SLIST [150:14]
+    |       |       |   |       `--LITERAL_THROW -> throw [150:14]
+    |       |       |   |           |--EXPR -> EXPR [150:20]
+    |       |       |   |           |   `--LITERAL_NEW -> new [150:20]
+    |       |       |   |           |       |--IDENT -> RuntimeException [150:24]
+    |       |       |   |           |       |--LPAREN -> ( [150:40]
+    |       |       |   |           |       |--ELIST -> ELIST [150:41]
+    |       |       |   |           |       |   `--EXPR -> EXPR [150:41]
+    |       |       |   |           |       |       `--STRING_LITERAL -> "" [150:41]
+    |       |       |   |           |       `--RPAREN -> ) [150:43]
+    |       |       |   |           `--SEMI -> ; [150:44]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [151:10]
+    |       |       |   |   |--LITERAL_CASE -> case [151:10]
+    |       |       |   |   |   |--EXPR -> EXPR [151:15]
+    |       |       |   |   |   |   `--NUM_INT -> 6 [151:15]
+    |       |       |   |   |   `--COLON -> : [151:16]
+    |       |       |   |   `--SLIST -> SLIST [152:14]
+    |       |       |   |       `--LITERAL_CONTINUE -> continue [152:14]
+    |       |       |   |           `--SEMI -> ; [152:22]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [153:10]
+    |       |       |   |   |--LITERAL_CASE -> case [153:10]
+    |       |       |   |   |   |--EXPR -> EXPR [153:15]
+    |       |       |   |   |   |   `--NUM_INT -> 7 [153:15]
+    |       |       |   |   |   `--COLON -> : [153:16]
+    |       |       |   |   `--SLIST -> SLIST [153:18]
+    |       |       |   |       `--SLIST -> { [153:18]
+    |       |       |   |           |--LITERAL_BREAK -> break [154:14]
+    |       |       |   |           |   `--SEMI -> ; [154:19]
+    |       |       |   |           `--RCURLY -> } [155:10]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [156:10]
+    |       |       |   |   |--LITERAL_CASE -> case [156:10]
+    |       |       |   |   |   |--EXPR -> EXPR [156:15]
+    |       |       |   |   |   |   `--NUM_INT -> 8 [156:15]
+    |       |       |   |   |   `--COLON -> : [156:16]
+    |       |       |   |   `--SLIST -> SLIST [156:18]
+    |       |       |   |       `--SLIST -> { [156:18]
+    |       |       |   |           |--LITERAL_RETURN -> return [157:14]
+    |       |       |   |           |   `--SEMI -> ; [157:20]
+    |       |       |   |           `--RCURLY -> } [158:10]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [159:10]
+    |       |       |   |   |--LITERAL_CASE -> case [159:10]
+    |       |       |   |   |   |--EXPR -> EXPR [159:15]
+    |       |       |   |   |   |   `--NUM_INT -> 9 [159:15]
+    |       |       |   |   |   `--COLON -> : [159:16]
+    |       |       |   |   `--SLIST -> SLIST [159:18]
+    |       |       |   |       `--SLIST -> { [159:18]
+    |       |       |   |           |--LITERAL_THROW -> throw [160:14]
+    |       |       |   |           |   |--EXPR -> EXPR [160:20]
+    |       |       |   |           |   |   `--LITERAL_NEW -> new [160:20]
+    |       |       |   |           |   |       |--IDENT -> RuntimeException [160:24]
+    |       |       |   |           |   |       |--LPAREN -> ( [160:40]
+    |       |       |   |           |   |       |--ELIST -> ELIST [160:41]
+    |       |       |   |           |   |       |   `--EXPR -> EXPR [160:41]
+    |       |       |   |           |   |       |       `--STRING_LITERAL -> "" [160:41]
+    |       |       |   |           |   |       `--RPAREN -> ) [160:43]
+    |       |       |   |           |   `--SEMI -> ; [160:44]
+    |       |       |   |           `--RCURLY -> } [161:10]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [162:10]
+    |       |       |   |   |--LITERAL_CASE -> case [162:10]
+    |       |       |   |   |   |--EXPR -> EXPR [162:15]
+    |       |       |   |   |   |   `--NUM_INT -> 10 [162:15]
+    |       |       |   |   |   `--COLON -> : [162:17]
+    |       |       |   |   `--SLIST -> SLIST [162:19]
+    |       |       |   |       `--SLIST -> { [162:19]
+    |       |       |   |           |--LITERAL_CONTINUE -> continue [163:14]
+    |       |       |   |           |   `--SEMI -> ; [163:22]
+    |       |       |   |           `--RCURLY -> } [164:10]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [165:10]
+    |       |       |   |   |--LITERAL_CASE -> case [165:10]
+    |       |       |   |   |   |--EXPR -> EXPR [165:15]
+    |       |       |   |   |   |   `--NUM_INT -> 11 [165:15]
+    |       |       |   |   |   `--COLON -> : [165:17]
+    |       |       |   |   `--SLIST -> SLIST [165:19]
+    |       |       |   |       `--SLIST -> { [165:19]
+    |       |       |   |           |--EXPR -> EXPR [166:15]
+    |       |       |   |           |   `--POST_INC -> ++ [166:15]
+    |       |       |   |           |       `--IDENT -> i [166:14]
+    |       |       |   |           |--SEMI -> ; [166:17]
+    |       |       |   |           `--RCURLY -> } [167:10]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [169:10]
+    |       |       |   |   |--LITERAL_CASE -> case [169:10]
+    |       |       |   |   |   |--EXPR -> EXPR [169:15]
+    |       |       |   |   |   |   `--NUM_INT -> 12 [169:15]
+    |       |       |   |   |   `--COLON -> : [169:17]
+    |       |       |   |   `--SLIST -> SLIST [170:14]
+    |       |       |   |       `--LITERAL_IF -> if [170:14]
+    |       |       |   |           |--LPAREN -> ( [170:17]
+    |       |       |   |           |--EXPR -> EXPR [170:18]
+    |       |       |   |           |   `--LITERAL_FALSE -> false [170:18]
+    |       |       |   |           |--RPAREN -> ) [170:23]
+    |       |       |   |           |--LITERAL_BREAK -> break [171:18]
+    |       |       |   |           |   `--SEMI -> ; [171:23]
+    |       |       |   |           `--LITERAL_ELSE -> else [172:14]
+    |       |       |   |               `--LITERAL_BREAK -> break [173:18]
+    |       |       |   |                   `--SEMI -> ; [173:23]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [174:10]
+    |       |       |   |   |--LITERAL_CASE -> case [174:10]
+    |       |       |   |   |   |--EXPR -> EXPR [174:15]
+    |       |       |   |   |   |   `--NUM_INT -> 13 [174:15]
+    |       |       |   |   |   `--COLON -> : [174:17]
+    |       |       |   |   `--SLIST -> SLIST [175:14]
+    |       |       |   |       `--LITERAL_IF -> if [175:14]
+    |       |       |   |           |--LPAREN -> ( [175:17]
+    |       |       |   |           |--EXPR -> EXPR [175:18]
+    |       |       |   |           |   `--LITERAL_TRUE -> true [175:18]
+    |       |       |   |           |--RPAREN -> ) [175:22]
+    |       |       |   |           `--SLIST -> { [175:24]
+    |       |       |   |               |--LITERAL_RETURN -> return [176:18]
+    |       |       |   |               |   `--SEMI -> ; [176:24]
+    |       |       |   |               `--RCURLY -> } [177:14]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [178:10]
+    |       |       |   |   |--LITERAL_CASE -> case [178:10]
+    |       |       |   |   |   |--EXPR -> EXPR [178:15]
+    |       |       |   |   |   |   `--NUM_INT -> 14 [178:15]
+    |       |       |   |   |   `--COLON -> : [178:17]
+    |       |       |   |   `--SLIST -> SLIST [179:14]
+    |       |       |   |       `--LITERAL_IF -> if [179:14]
+    |       |       |   |           |--LPAREN -> ( [179:17]
+    |       |       |   |           |--EXPR -> EXPR [179:18]
+    |       |       |   |           |   `--LITERAL_TRUE -> true [179:18]
+    |       |       |   |           |--RPAREN -> ) [179:22]
+    |       |       |   |           |--SLIST -> { [179:24]
+    |       |       |   |           |   |--LITERAL_RETURN -> return [180:18]
+    |       |       |   |           |   |   `--SEMI -> ; [180:24]
+    |       |       |   |           |   `--RCURLY -> } [181:14]
+    |       |       |   |           `--LITERAL_ELSE -> else [181:16]
+    |       |       |   |               `--SLIST -> { [181:21]
+    |       |       |   |                   `--RCURLY -> } [183:14]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [185:10]
+    |       |       |   |   |--LITERAL_CASE -> case [185:10]
+    |       |       |   |   |   |--EXPR -> EXPR [185:15]
+    |       |       |   |   |   |   `--NUM_INT -> 15 [185:15]
+    |       |       |   |   |   `--COLON -> : [185:17]
+    |       |       |   |   `--SLIST -> SLIST [186:14]
+    |       |       |   |       `--LITERAL_DO -> do [186:14]
+    |       |       |   |           |--SLIST -> { [186:17]
+    |       |       |   |           |   |--EXPR -> EXPR [187:41]
+    |       |       |   |           |   |   `--METHOD_CALL -> ( [187:41]
+    |       |       |   |           |   |       |--DOT -> . [187:24]
+    |       |       |   |           |   |       |   |--IDENT -> System [187:18]
+    |       |       |   |           |   |       |   `--IDENT -> identityHashCode [187:25]
+    |       |       |   |           |   |       |--ELIST -> ELIST [187:42]
+    |       |       |   |           |   |       |   `--EXPR -> EXPR [187:42]
+    |       |       |   |           |   |       |       `--STRING_LITERAL -> "something" [187:42]
+    |       |       |   |           |   |       `--RPAREN -> ) [187:53]
+    |       |       |   |           |   |--SEMI -> ; [187:54]
+    |       |       |   |           |   |--LITERAL_RETURN -> return [188:18]
+    |       |       |   |           |   |   `--SEMI -> ; [188:24]
+    |       |       |   |           |   `--RCURLY -> } [189:14]
+    |       |       |   |           |--DO_WHILE -> while [189:16]
+    |       |       |   |           |--LPAREN -> ( [189:21]
+    |       |       |   |           |--EXPR -> EXPR [189:22]
+    |       |       |   |           |   `--LITERAL_TRUE -> true [189:22]
+    |       |       |   |           |--RPAREN -> ) [189:26]
+    |       |       |   |           `--SEMI -> ; [189:27]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [190:10]
+    |       |       |   |   |--LITERAL_CASE -> case [190:10]
+    |       |       |   |   |   |--EXPR -> EXPR [190:15]
+    |       |       |   |   |   |   `--NUM_INT -> 16 [190:15]
+    |       |       |   |   |   `--COLON -> : [190:17]
+    |       |       |   |   `--SLIST -> SLIST [191:14]
+    |       |       |   |       `--LITERAL_FOR -> for [191:14]
+    |       |       |   |           |--LPAREN -> ( [191:18]
+    |       |       |   |           |--FOR_INIT -> FOR_INIT [191:19]
+    |       |       |   |           |   `--VARIABLE_DEF -> VARIABLE_DEF [191:19]
+    |       |       |   |           |       |--MODIFIERS -> MODIFIERS [191:19]
+    |       |       |   |           |       |--TYPE -> TYPE [191:19]
+    |       |       |   |           |       |   `--LITERAL_INT -> int [191:19]
+    |       |       |   |           |       |--IDENT -> j1 [191:23]
+    |       |       |   |           |       `--ASSIGN -> = [191:26]
+    |       |       |   |           |           `--EXPR -> EXPR [191:28]
+    |       |       |   |           |               `--NUM_INT -> 0 [191:28]
+    |       |       |   |           |--SEMI -> ; [191:29]
+    |       |       |   |           |--FOR_CONDITION -> FOR_CONDITION [191:34]
+    |       |       |   |           |   `--EXPR -> EXPR [191:34]
+    |       |       |   |           |       `--LT -> < [191:34]
+    |       |       |   |           |           |--IDENT -> j1 [191:31]
+    |       |       |   |           |           `--NUM_INT -> 10 [191:36]
+    |       |       |   |           |--SEMI -> ; [191:38]
+    |       |       |   |           |--FOR_ITERATOR -> FOR_ITERATOR [191:42]
+    |       |       |   |           |   `--ELIST -> ELIST [191:42]
+    |       |       |   |           |       `--EXPR -> EXPR [191:42]
+    |       |       |   |           |           `--POST_INC -> ++ [191:42]
+    |       |       |   |           |               `--IDENT -> j1 [191:40]
+    |       |       |   |           |--RPAREN -> ) [191:44]
+    |       |       |   |           `--SLIST -> { [191:46]
+    |       |       |   |               |--EXPR -> EXPR [192:32]
+    |       |       |   |               |   `--METHOD_CALL -> ( [192:32]
+    |       |       |   |               |       |--DOT -> . [192:24]
+    |       |       |   |               |       |   |--IDENT -> String [192:18]
+    |       |       |   |               |       |   `--IDENT -> valueOf [192:25]
+    |       |       |   |               |       |--ELIST -> ELIST [192:33]
+    |       |       |   |               |       |   `--EXPR -> EXPR [192:33]
+    |       |       |   |               |       |       `--STRING_LITERAL -> "something" [192:33]
+    |       |       |   |               |       `--RPAREN -> ) [192:44]
+    |       |       |   |               |--SEMI -> ; [192:45]
+    |       |       |   |               |--LITERAL_RETURN -> return [193:18]
+    |       |       |   |               |   `--SEMI -> ; [193:24]
+    |       |       |   |               `--RCURLY -> } [194:14]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [195:10]
+    |       |       |   |   |--LITERAL_CASE -> case [195:10]
+    |       |       |   |   |   |--EXPR -> EXPR [195:15]
+    |       |       |   |   |   |   `--NUM_INT -> 17 [195:15]
+    |       |       |   |   |   `--COLON -> : [195:17]
+    |       |       |   |   `--SLIST -> SLIST [196:14]
+    |       |       |   |       `--LITERAL_WHILE -> while [196:14]
+    |       |       |   |           |--LPAREN -> ( [196:20]
+    |       |       |   |           |--EXPR -> EXPR [196:21]
+    |       |       |   |           |   `--IDENT -> cond [196:21]
+    |       |       |   |           |--RPAREN -> ) [196:25]
+    |       |       |   |           `--LITERAL_THROW -> throw [197:18]
+    |       |       |   |               |--EXPR -> EXPR [197:24]
+    |       |       |   |               |   `--LITERAL_NEW -> new [197:24]
+    |       |       |   |               |       |--IDENT -> RuntimeException [197:28]
+    |       |       |   |               |       |--LPAREN -> ( [197:44]
+    |       |       |   |               |       |--ELIST -> ELIST [197:45]
+    |       |       |   |               |       |   `--EXPR -> EXPR [197:45]
+    |       |       |   |               |       |       `--STRING_LITERAL -> "" [197:45]
+    |       |       |   |               |       `--RPAREN -> ) [197:47]
+    |       |       |   |               `--SEMI -> ; [197:48]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [198:10]
+    |       |       |   |   |--LITERAL_CASE -> case [198:10]
+    |       |       |   |   |   |--EXPR -> EXPR [198:15]
+    |       |       |   |   |   |   `--NUM_INT -> 18 [198:15]
+    |       |       |   |   |   `--COLON -> : [198:17]
+    |       |       |   |   `--SLIST -> SLIST [199:14]
+    |       |       |   |       `--LITERAL_WHILE -> while [199:14]
+    |       |       |   |           |--LPAREN -> ( [199:19]
+    |       |       |   |           |--EXPR -> EXPR [199:20]
+    |       |       |   |           |   `--IDENT -> cond [199:20]
+    |       |       |   |           |--RPAREN -> ) [199:24]
+    |       |       |   |           `--SLIST -> { [199:26]
+    |       |       |   |               |--LITERAL_BREAK -> break [200:18]
+    |       |       |   |               |   `--SEMI -> ; [200:23]
+    |       |       |   |               `--RCURLY -> } [201:14]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [203:10]
+    |       |       |   |   |--LITERAL_CASE -> case [203:10]
+    |       |       |   |   |   |--EXPR -> EXPR [203:15]
+    |       |       |   |   |   |   `--NUM_INT -> 19 [203:15]
+    |       |       |   |   |   `--COLON -> : [203:17]
+    |       |       |   |   `--SLIST -> SLIST [204:14]
+    |       |       |   |       `--LITERAL_TRY -> try [204:14]
+    |       |       |   |           |--SLIST -> { [204:18]
+    |       |       |   |           |   |--EXPR -> EXPR [205:19]
+    |       |       |   |           |   |   `--POST_INC -> ++ [205:19]
+    |       |       |   |           |   |       `--IDENT -> i [205:18]
+    |       |       |   |           |   |--SEMI -> ; [205:21]
+    |       |       |   |           |   |--LITERAL_BREAK -> break [206:18]
+    |       |       |   |           |   |   `--SEMI -> ; [206:23]
+    |       |       |   |           |   `--RCURLY -> } [207:14]
+    |       |       |   |           |--LITERAL_CATCH -> catch [207:16]
+    |       |       |   |           |   |--LPAREN -> ( [207:22]
+    |       |       |   |           |   |--PARAMETER_DEF -> PARAMETER_DEF [207:23]
+    |       |       |   |           |   |   |--MODIFIERS -> MODIFIERS [207:23]
+    |       |       |   |           |   |   |--TYPE -> TYPE [207:23]
+    |       |       |   |           |   |   |   `--IDENT -> RuntimeException [207:23]
+    |       |       |   |           |   |   `--IDENT -> e [207:40]
+    |       |       |   |           |   |--RPAREN -> ) [207:41]
+    |       |       |   |           |   `--SLIST -> { [207:43]
+    |       |       |   |           |       |--LITERAL_BREAK -> break [208:18]
+    |       |       |   |           |       |   `--SEMI -> ; [208:23]
+    |       |       |   |           |       `--RCURLY -> } [209:14]
+    |       |       |   |           `--LITERAL_CATCH -> catch [209:16]
+    |       |       |   |               |--LPAREN -> ( [209:22]
+    |       |       |   |               |--PARAMETER_DEF -> PARAMETER_DEF [209:23]
+    |       |       |   |               |   |--MODIFIERS -> MODIFIERS [209:23]
+    |       |       |   |               |   |--TYPE -> TYPE [209:23]
+    |       |       |   |               |   |   `--IDENT -> Error [209:23]
+    |       |       |   |               |   `--IDENT -> e [209:29]
+    |       |       |   |               |--RPAREN -> ) [209:30]
+    |       |       |   |               `--SLIST -> { [209:32]
+    |       |       |   |                   |--LITERAL_RETURN -> return [210:18]
+    |       |       |   |                   |   `--SEMI -> ; [210:24]
+    |       |       |   |                   `--RCURLY -> } [211:14]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [212:10]
+    |       |       |   |   |--LITERAL_CASE -> case [212:10]
+    |       |       |   |   |   |--EXPR -> EXPR [212:15]
+    |       |       |   |   |   |   `--NUM_INT -> 20 [212:15]
+    |       |       |   |   |   `--COLON -> : [212:17]
+    |       |       |   |   `--SLIST -> SLIST [213:14]
+    |       |       |   |       `--LITERAL_TRY -> try [213:14]
+    |       |       |   |           |--SLIST -> { [213:18]
+    |       |       |   |           |   |--EXPR -> EXPR [214:19]
+    |       |       |   |           |   |   `--POST_INC -> ++ [214:19]
+    |       |       |   |           |   |       `--IDENT -> i [214:18]
+    |       |       |   |           |   |--SEMI -> ; [214:21]
+    |       |       |   |           |   |--LITERAL_BREAK -> break [215:18]
+    |       |       |   |           |   |   `--SEMI -> ; [215:23]
+    |       |       |   |           |   `--RCURLY -> } [216:14]
+    |       |       |   |           |--LITERAL_CATCH -> catch [216:16]
+    |       |       |   |           |   |--LPAREN -> ( [216:22]
+    |       |       |   |           |   |--PARAMETER_DEF -> PARAMETER_DEF [216:23]
+    |       |       |   |           |   |   |--MODIFIERS -> MODIFIERS [216:23]
+    |       |       |   |           |   |   |--TYPE -> TYPE [216:23]
+    |       |       |   |           |   |   |   `--IDENT -> RuntimeException [216:23]
+    |       |       |   |           |   |   `--IDENT -> e [216:40]
+    |       |       |   |           |   |--RPAREN -> ) [216:41]
+    |       |       |   |           |   `--SLIST -> { [216:43]
+    |       |       |   |           |       `--RCURLY -> } [217:14]
+    |       |       |   |           `--LITERAL_CATCH -> catch [217:16]
+    |       |       |   |               |--LPAREN -> ( [217:22]
+    |       |       |   |               |--PARAMETER_DEF -> PARAMETER_DEF [217:23]
+    |       |       |   |               |   |--MODIFIERS -> MODIFIERS [217:23]
+    |       |       |   |               |   |--TYPE -> TYPE [217:23]
+    |       |       |   |               |   |   `--IDENT -> Error [217:23]
+    |       |       |   |               |   `--IDENT -> e [217:29]
+    |       |       |   |               |--RPAREN -> ) [217:30]
+    |       |       |   |               `--SLIST -> { [217:32]
+    |       |       |   |                   |--LITERAL_RETURN -> return [218:18]
+    |       |       |   |                   |   `--SEMI -> ; [218:24]
+    |       |       |   |                   `--RCURLY -> } [219:14]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [221:10]
+    |       |       |   |   |--LITERAL_CASE -> case [221:10]
+    |       |       |   |   |   |--EXPR -> EXPR [221:15]
+    |       |       |   |   |   |   `--NUM_INT -> 21 [221:15]
+    |       |       |   |   |   `--COLON -> : [221:17]
+    |       |       |   |   `--SLIST -> SLIST [222:14]
+    |       |       |   |       `--LITERAL_TRY -> try [222:14]
+    |       |       |   |           |--SLIST -> { [222:18]
+    |       |       |   |           |   |--EXPR -> EXPR [223:19]
+    |       |       |   |           |   |   `--POST_INC -> ++ [223:19]
+    |       |       |   |           |   |       `--IDENT -> i [223:18]
+    |       |       |   |           |   |--SEMI -> ; [223:21]
+    |       |       |   |           |   `--RCURLY -> } [224:14]
+    |       |       |   |           |--LITERAL_CATCH -> catch [224:16]
+    |       |       |   |           |   |--LPAREN -> ( [224:22]
+    |       |       |   |           |   |--PARAMETER_DEF -> PARAMETER_DEF [224:23]
+    |       |       |   |           |   |   |--MODIFIERS -> MODIFIERS [224:23]
+    |       |       |   |           |   |   |--TYPE -> TYPE [224:23]
+    |       |       |   |           |   |   |   `--IDENT -> RuntimeException [224:23]
+    |       |       |   |           |   |   `--IDENT -> e [224:40]
+    |       |       |   |           |   |--RPAREN -> ) [224:41]
+    |       |       |   |           |   `--SLIST -> { [224:43]
+    |       |       |   |           |       |--EXPR -> EXPR [225:19]
+    |       |       |   |           |       |   `--POST_DEC -> -- [225:19]
+    |       |       |   |           |       |       `--IDENT -> i [225:18]
+    |       |       |   |           |       |--SEMI -> ; [225:21]
+    |       |       |   |           |       `--RCURLY -> } [226:14]
+    |       |       |   |           `--LITERAL_FINALLY -> finally [226:16]
+    |       |       |   |               `--SLIST -> { [226:24]
+    |       |       |   |                   |--LITERAL_BREAK -> break [227:18]
+    |       |       |   |                   |   `--SEMI -> ; [227:23]
+    |       |       |   |                   `--RCURLY -> } [228:14]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [229:10]
+    |       |       |   |   |--LITERAL_CASE -> case [229:10]
+    |       |       |   |   |   |--EXPR -> EXPR [229:15]
+    |       |       |   |   |   |   `--NUM_INT -> 22 [229:15]
+    |       |       |   |   |   `--COLON -> : [229:17]
+    |       |       |   |   `--SLIST -> SLIST [230:14]
+    |       |       |   |       `--LITERAL_TRY -> try [230:14]
+    |       |       |   |           |--SLIST -> { [230:18]
+    |       |       |   |           |   |--EXPR -> EXPR [231:19]
+    |       |       |   |           |   |   `--POST_INC -> ++ [231:19]
+    |       |       |   |           |   |       `--IDENT -> i [231:18]
+    |       |       |   |           |   |--SEMI -> ; [231:21]
+    |       |       |   |           |   |--LITERAL_BREAK -> break [232:18]
+    |       |       |   |           |   |   `--SEMI -> ; [232:23]
+    |       |       |   |           |   `--RCURLY -> } [233:14]
+    |       |       |   |           |--LITERAL_CATCH -> catch [233:16]
+    |       |       |   |           |   |--LPAREN -> ( [233:22]
+    |       |       |   |           |   |--PARAMETER_DEF -> PARAMETER_DEF [233:23]
+    |       |       |   |           |   |   |--MODIFIERS -> MODIFIERS [233:23]
+    |       |       |   |           |   |   |--TYPE -> TYPE [233:23]
+    |       |       |   |           |   |   |   `--IDENT -> RuntimeException [233:23]
+    |       |       |   |           |   |   `--IDENT -> e [233:40]
+    |       |       |   |           |   |--RPAREN -> ) [233:41]
+    |       |       |   |           |   `--SLIST -> { [233:43]
+    |       |       |   |           |       |--EXPR -> EXPR [234:19]
+    |       |       |   |           |       |   `--POST_DEC -> -- [234:19]
+    |       |       |   |           |       |       `--IDENT -> i [234:18]
+    |       |       |   |           |       |--SEMI -> ; [234:21]
+    |       |       |   |           |       |--LITERAL_BREAK -> break [235:18]
+    |       |       |   |           |       |   `--SEMI -> ; [235:23]
+    |       |       |   |           |       `--RCURLY -> } [236:14]
+    |       |       |   |           `--LITERAL_FINALLY -> finally [236:16]
+    |       |       |   |               `--SLIST -> { [236:24]
+    |       |       |   |                   |--EXPR -> EXPR [237:19]
+    |       |       |   |                   |   `--POST_INC -> ++ [237:19]
+    |       |       |   |                   |       `--IDENT -> i [237:18]
+    |       |       |   |                   |--SEMI -> ; [237:21]
+    |       |       |   |                   `--RCURLY -> } [238:14]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [240:10]
+    |       |       |   |   |--LITERAL_CASE -> case [240:10]
+    |       |       |   |   |   |--EXPR -> EXPR [240:15]
+    |       |       |   |   |   |   `--NUM_INT -> 23 [240:15]
+    |       |       |   |   |   `--COLON -> : [240:17]
+    |       |       |   |   `--SLIST -> SLIST [241:14]
+    |       |       |   |       `--LITERAL_SWITCH -> switch [241:14]
+    |       |       |   |           |--LPAREN -> ( [241:21]
+    |       |       |   |           |--EXPR -> EXPR [241:22]
+    |       |       |   |           |   `--IDENT -> j [241:22]
+    |       |       |   |           |--RPAREN -> ) [241:23]
+    |       |       |   |           |--LCURLY -> { [241:25]
+    |       |       |   |           |--CASE_GROUP -> CASE_GROUP [242:14]
+    |       |       |   |           |   |--LITERAL_CASE -> case [242:14]
+    |       |       |   |           |   |   |--EXPR -> EXPR [242:19]
+    |       |       |   |           |   |   |   `--NUM_INT -> 1 [242:19]
+    |       |       |   |           |   |   `--COLON -> : [242:20]
+    |       |       |   |           |   `--SLIST -> SLIST [243:18]
+    |       |       |   |           |       `--LITERAL_CONTINUE -> continue [243:18]
+    |       |       |   |           |           `--SEMI -> ; [243:26]
+    |       |       |   |           |--CASE_GROUP -> CASE_GROUP [244:14]
+    |       |       |   |           |   |--LITERAL_CASE -> case [244:14]
+    |       |       |   |           |   |   |--EXPR -> EXPR [244:19]
+    |       |       |   |           |   |   |   `--NUM_INT -> 2 [244:19]
+    |       |       |   |           |   |   `--COLON -> : [244:20]
+    |       |       |   |           |   `--SLIST -> SLIST [245:18]
+    |       |       |   |           |       `--LITERAL_RETURN -> return [245:18]
+    |       |       |   |           |           `--SEMI -> ; [245:24]
+    |       |       |   |           |--CASE_GROUP -> CASE_GROUP [246:14]
+    |       |       |   |           |   |--LITERAL_DEFAULT -> default [246:14]
+    |       |       |   |           |   |   `--COLON -> : [246:21]
+    |       |       |   |           |   `--SLIST -> SLIST [247:18]
+    |       |       |   |           |       `--LITERAL_RETURN -> return [247:18]
+    |       |       |   |           |           `--SEMI -> ; [247:24]
+    |       |       |   |           `--RCURLY -> } [248:14]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [249:10]
+    |       |       |   |   |--LITERAL_CASE -> case [249:10]
+    |       |       |   |   |   |--EXPR -> EXPR [249:15]
+    |       |       |   |   |   |   `--NUM_INT -> 24 [249:15]
+    |       |       |   |   |   `--COLON -> : [249:17]
+    |       |       |   |   `--SLIST -> SLIST [250:15]
+    |       |       |   |       |--EXPR -> EXPR [250:15]
+    |       |       |   |       |   `--POST_INC -> ++ [250:15]
+    |       |       |   |       |       `--IDENT -> i [250:14]
+    |       |       |   |       `--SEMI -> ; [250:17]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [251:25]
+    |       |       |   |   |--LITERAL_CASE -> case [251:25]
+    |       |       |   |   |   |--EXPR -> EXPR [251:30]
+    |       |       |   |   |   |   `--NUM_INT -> 25 [251:30]
+    |       |       |   |   |   `--COLON -> : [251:32]
+    |       |       |   |   `--SLIST -> SLIST [252:15]
+    |       |       |   |       |--EXPR -> EXPR [252:15]
+    |       |       |   |       |   `--POST_INC -> ++ [252:15]
+    |       |       |   |       |       `--IDENT -> i [252:14]
+    |       |       |   |       |--SEMI -> ; [252:17]
+    |       |       |   |       `--LITERAL_BREAK -> break [253:14]
+    |       |       |   |           `--SEMI -> ; [253:19]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [255:10]
+    |       |       |   |   |--LITERAL_CASE -> case [255:10]
+    |       |       |   |   |   |--EXPR -> EXPR [255:15]
+    |       |       |   |   |   |   `--NUM_INT -> 26 [255:15]
+    |       |       |   |   |   `--COLON -> : [255:17]
+    |       |       |   |   `--SLIST -> SLIST [256:14]
+    |       |       |   |       `--LITERAL_SWITCH -> switch [256:14]
+    |       |       |   |           |--LPAREN -> ( [256:21]
+    |       |       |   |           |--EXPR -> EXPR [256:22]
+    |       |       |   |           |   `--IDENT -> j [256:22]
+    |       |       |   |           |--RPAREN -> ) [256:23]
+    |       |       |   |           |--LCURLY -> { [256:25]
+    |       |       |   |           |--CASE_GROUP -> CASE_GROUP [257:14]
+    |       |       |   |           |   |--LITERAL_CASE -> case [257:14]
+    |       |       |   |           |   |   |--EXPR -> EXPR [257:19]
+    |       |       |   |           |   |   |   `--NUM_INT -> 1 [257:19]
+    |       |       |   |           |   |   `--COLON -> : [257:20]
+    |       |       |   |           |   `--SLIST -> SLIST [258:18]
+    |       |       |   |           |       `--LITERAL_CONTINUE -> continue [258:18]
+    |       |       |   |           |           `--SEMI -> ; [258:26]
+    |       |       |   |           |--CASE_GROUP -> CASE_GROUP [259:14]
+    |       |       |   |           |   |--LITERAL_CASE -> case [259:14]
+    |       |       |   |           |   |   |--EXPR -> EXPR [259:19]
+    |       |       |   |           |   |   |   `--NUM_INT -> 2 [259:19]
+    |       |       |   |           |   |   `--COLON -> : [259:20]
+    |       |       |   |           |   `--SLIST -> SLIST [260:18]
+    |       |       |   |           |       `--LITERAL_BREAK -> break [260:18]
+    |       |       |   |           |           `--SEMI -> ; [260:23]
+    |       |       |   |           |--CASE_GROUP -> CASE_GROUP [261:14]
+    |       |       |   |           |   |--LITERAL_DEFAULT -> default [261:14]
+    |       |       |   |           |   |   `--COLON -> : [261:21]
+    |       |       |   |           |   `--SLIST -> SLIST [262:18]
+    |       |       |   |           |       `--LITERAL_RETURN -> return [262:18]
+    |       |       |   |           |           `--SEMI -> ; [262:24]
+    |       |       |   |           `--RCURLY -> } [263:14]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [265:10]
+    |       |       |   |   |--LITERAL_DEFAULT -> default [265:10]
+    |       |       |   |   |   `--COLON -> : [265:17]
+    |       |       |   |   `--SLIST -> SLIST [267:15]
+    |       |       |   |       |--EXPR -> EXPR [267:15]
+    |       |       |   |       |   `--POST_INC -> ++ [267:15]
+    |       |       |   |       |       `--IDENT -> i [267:14]
+    |       |       |   |       `--SEMI -> ; [267:17]
+    |       |       |   `--RCURLY -> } [269:9]
+    |       |       `--RCURLY -> } [270:6]
+    |       `--RCURLY -> } [271:3]
+    |--METHOD_DEF -> METHOD_DEF [274:3]
+    |   |--MODIFIERS -> MODIFIERS [274:3]
+    |   |--TYPE -> TYPE [274:3]
+    |   |   `--LITERAL_VOID -> void [274:3]
+    |   |--IDENT -> methodFallThruCC [274:8]
+    |   |--LPAREN -> ( [274:24]
+    |   |--PARAMETERS -> PARAMETERS [274:25]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [274:25]
+    |   |   |   |--MODIFIERS -> MODIFIERS [274:25]
+    |   |   |   |--TYPE -> TYPE [274:25]
+    |   |   |   |   `--LITERAL_INT -> int [274:25]
+    |   |   |   `--IDENT -> i [274:29]
+    |   |   |--COMMA -> , [274:30]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [274:32]
+    |   |   |   |--MODIFIERS -> MODIFIERS [274:32]
+    |   |   |   |--TYPE -> TYPE [274:32]
+    |   |   |   |   `--LITERAL_INT -> int [274:32]
+    |   |   |   `--IDENT -> j [274:36]
+    |   |   |--COMMA -> , [274:37]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [274:39]
+    |   |       |--MODIFIERS -> MODIFIERS [274:39]
+    |   |       |--TYPE -> TYPE [274:39]
+    |   |       |   `--LITERAL_BOOLEAN -> boolean [274:39]
+    |   |       `--IDENT -> cond [274:47]
+    |   |--RPAREN -> ) [274:51]
+    |   `--SLIST -> { [274:53]
+    |       |--LITERAL_WHILE -> while [275:6]
+    |       |   |--LPAREN -> ( [275:12]
+    |       |   |--EXPR -> EXPR [275:13]
+    |       |   |   `--LITERAL_TRUE -> true [275:13]
+    |       |   |--RPAREN -> ) [275:17]
+    |       |   `--SLIST -> { [275:19]
+    |       |       |--LITERAL_SWITCH -> switch [276:10]
+    |       |       |   |--LPAREN -> ( [276:17]
+    |       |       |   |--EXPR -> EXPR [276:18]
+    |       |       |   |   `--IDENT -> i [276:18]
+    |       |       |   |--RPAREN -> ) [276:19]
+    |       |       |   |--LCURLY -> { [276:20]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [277:10]
+    |       |       |   |   |--LITERAL_CASE -> case [277:10]
+    |       |       |   |   |   |--EXPR -> EXPR [277:15]
+    |       |       |   |   |   |   `--NUM_INT -> 0 [277:15]
+    |       |       |   |   |   `--COLON -> : [277:16]
+    |       |       |   |   `--SLIST -> SLIST [278:15]
+    |       |       |   |       |--EXPR -> EXPR [278:15]
+    |       |       |   |       |   `--POST_INC -> ++ [278:15]
+    |       |       |   |       |       `--IDENT -> i [278:14]
+    |       |       |   |       `--SEMI -> ; [278:17]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [280:10]
+    |       |       |   |   |--LITERAL_CASE -> case [280:10]
+    |       |       |   |   |   |--EXPR -> EXPR [280:15]
+    |       |       |   |   |   |   `--NUM_INT -> 1 [280:15]
+    |       |       |   |   |   `--COLON -> : [280:16]
+    |       |       |   |   `--SLIST -> SLIST [281:15]
+    |       |       |   |       |--EXPR -> EXPR [281:15]
+    |       |       |   |       |   `--POST_INC -> ++ [281:15]
+    |       |       |   |       |       `--IDENT -> i [281:14]
+    |       |       |   |       `--SEMI -> ; [281:17]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [283:10]
+    |       |       |   |   |--LITERAL_CASE -> case [283:10]
+    |       |       |   |   |   |--EXPR -> EXPR [283:15]
+    |       |       |   |   |   |   `--NUM_INT -> 2 [283:15]
+    |       |       |   |   |   `--COLON -> : [283:16]
+    |       |       |   |   `--SLIST -> SLIST [283:18]
+    |       |       |   |       `--SLIST -> { [283:18]
+    |       |       |   |           |--EXPR -> EXPR [284:15]
+    |       |       |   |           |   `--POST_INC -> ++ [284:15]
+    |       |       |   |           |       `--IDENT -> i [284:14]
+    |       |       |   |           |--SEMI -> ; [284:17]
+    |       |       |   |           `--RCURLY -> } [285:10]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [287:10]
+    |       |       |   |   |--LITERAL_CASE -> case [287:10]
+    |       |       |   |   |   |--EXPR -> EXPR [287:15]
+    |       |       |   |   |   |   `--NUM_INT -> 3 [287:15]
+    |       |       |   |   |   `--COLON -> : [287:16]
+    |       |       |   |   `--SLIST -> SLIST [288:15]
+    |       |       |   |       |--EXPR -> EXPR [288:15]
+    |       |       |   |       |   `--POST_INC -> ++ [288:15]
+    |       |       |   |       |       `--IDENT -> i [288:14]
+    |       |       |   |       `--SEMI -> ; [288:17]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [289:24]
+    |       |       |   |   |--LITERAL_CASE -> case [289:24]
+    |       |       |   |   |   |--EXPR -> EXPR [289:29]
+    |       |       |   |   |   |   `--NUM_INT -> 4 [289:29]
+    |       |       |   |   |   `--COLON -> : [289:30]
+    |       |       |   |   `--SLIST -> SLIST [290:16]
+    |       |       |   |       `--LITERAL_BREAK -> break [290:16]
+    |       |       |   |           `--SEMI -> ; [290:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [291:10]
+    |       |       |   |   |--LITERAL_CASE -> case [291:10]
+    |       |       |   |   |   |--EXPR -> EXPR [291:15]
+    |       |       |   |   |   |   `--NUM_INT -> 5 [291:15]
+    |       |       |   |   |   `--COLON -> : [291:16]
+    |       |       |   |   `--SLIST -> SLIST [292:15]
+    |       |       |   |       |--EXPR -> EXPR [292:15]
+    |       |       |   |       |   `--POST_INC -> ++ [292:15]
+    |       |       |   |       |       `--IDENT -> i [292:14]
+    |       |       |   |       `--SEMI -> ; [292:17]
+    |       |       |   `--RCURLY -> } [294:10]
+    |       |       `--RCURLY -> } [295:6]
+    |       `--RCURLY -> } [296:3]
+    |--METHOD_DEF -> METHOD_DEF [299:3]
+    |   |--MODIFIERS -> MODIFIERS [299:3]
+    |   |--TYPE -> TYPE [299:3]
+    |   |   `--LITERAL_VOID -> void [299:3]
+    |   |--IDENT -> methodFallThruC [299:8]
+    |   |--LPAREN -> ( [299:23]
+    |   |--PARAMETERS -> PARAMETERS [299:24]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [299:24]
+    |   |   |   |--MODIFIERS -> MODIFIERS [299:24]
+    |   |   |   |--TYPE -> TYPE [299:24]
+    |   |   |   |   `--LITERAL_INT -> int [299:24]
+    |   |   |   `--IDENT -> i [299:28]
+    |   |   |--COMMA -> , [299:29]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [299:31]
+    |   |   |   |--MODIFIERS -> MODIFIERS [299:31]
+    |   |   |   |--TYPE -> TYPE [299:31]
+    |   |   |   |   `--LITERAL_INT -> int [299:31]
+    |   |   |   `--IDENT -> j [299:35]
+    |   |   |--COMMA -> , [299:36]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [299:38]
+    |   |       |--MODIFIERS -> MODIFIERS [299:38]
+    |   |       |--TYPE -> TYPE [299:38]
+    |   |       |   `--LITERAL_BOOLEAN -> boolean [299:38]
+    |   |       `--IDENT -> cond [299:46]
+    |   |--RPAREN -> ) [299:50]
+    |   `--SLIST -> { [299:52]
+    |       |--LITERAL_WHILE -> while [300:6]
+    |       |   |--LPAREN -> ( [300:12]
+    |       |   |--EXPR -> EXPR [300:13]
+    |       |   |   `--LITERAL_TRUE -> true [300:13]
+    |       |   |--RPAREN -> ) [300:17]
+    |       |   `--SLIST -> { [300:19]
+    |       |       |--LITERAL_SWITCH -> switch [301:10]
+    |       |       |   |--LPAREN -> ( [301:17]
+    |       |       |   |--EXPR -> EXPR [301:18]
+    |       |       |   |   `--IDENT -> i [301:18]
+    |       |       |   |--RPAREN -> ) [301:19]
+    |       |       |   |--LCURLY -> { [301:20]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [302:10]
+    |       |       |   |   |--LITERAL_CASE -> case [302:10]
+    |       |       |   |   |   |--EXPR -> EXPR [302:15]
+    |       |       |   |   |   |   `--NUM_INT -> 0 [302:15]
+    |       |       |   |   |   `--COLON -> : [302:16]
+    |       |       |   |   `--SLIST -> SLIST [303:15]
+    |       |       |   |       |--EXPR -> EXPR [303:15]
+    |       |       |   |       |   `--POST_INC -> ++ [303:15]
+    |       |       |   |       |       `--IDENT -> i [303:14]
+    |       |       |   |       `--SEMI -> ; [303:17]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [305:10]
+    |       |       |   |   |--LITERAL_CASE -> case [305:10]
+    |       |       |   |   |   |--EXPR -> EXPR [305:15]
+    |       |       |   |   |   |   `--NUM_INT -> 1 [305:15]
+    |       |       |   |   |   `--COLON -> : [305:16]
+    |       |       |   |   `--SLIST -> SLIST [306:15]
+    |       |       |   |       |--EXPR -> EXPR [306:15]
+    |       |       |   |       |   `--POST_INC -> ++ [306:15]
+    |       |       |   |       |       `--IDENT -> i [306:14]
+    |       |       |   |       `--SEMI -> ; [306:17]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [308:10]
+    |       |       |   |   |--LITERAL_CASE -> case [308:10]
+    |       |       |   |   |   |--EXPR -> EXPR [308:15]
+    |       |       |   |   |   |   `--NUM_INT -> 2 [308:15]
+    |       |       |   |   |   `--COLON -> : [308:16]
+    |       |       |   |   `--SLIST -> SLIST [309:15]
+    |       |       |   |       |--EXPR -> EXPR [309:15]
+    |       |       |   |       |   `--POST_INC -> ++ [309:15]
+    |       |       |   |       |       `--IDENT -> i [309:14]
+    |       |       |   |       `--SEMI -> ; [309:17]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [310:24]
+    |       |       |   |   |--LITERAL_CASE -> case [310:24]
+    |       |       |   |   |   |--EXPR -> EXPR [310:29]
+    |       |       |   |   |   |   `--NUM_INT -> 3 [310:29]
+    |       |       |   |   |   `--COLON -> : [310:30]
+    |       |       |   |   `--SLIST -> SLIST [311:16]
+    |       |       |   |       `--LITERAL_BREAK -> break [311:16]
+    |       |       |   |           `--SEMI -> ; [311:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [312:10]
+    |       |       |   |   |--LITERAL_CASE -> case [312:10]
+    |       |       |   |   |   |--EXPR -> EXPR [312:15]
+    |       |       |   |   |   |   `--NUM_INT -> 4 [312:15]
+    |       |       |   |   |   `--COLON -> : [312:16]
+    |       |       |   |   `--SLIST -> SLIST [313:15]
+    |       |       |   |       |--EXPR -> EXPR [313:15]
+    |       |       |   |       |   `--POST_INC -> ++ [313:15]
+    |       |       |   |       |       `--IDENT -> i [313:14]
+    |       |       |   |       `--SEMI -> ; [313:17]
+    |       |       |   `--RCURLY -> } [315:10]
+    |       |       `--RCURLY -> } [316:6]
+    |       `--RCURLY -> } [317:3]
+    |--METHOD_DEF -> METHOD_DEF [320:3]
+    |   |--MODIFIERS -> MODIFIERS [320:3]
+    |   |--TYPE -> TYPE [320:3]
+    |   |   `--LITERAL_VOID -> void [320:3]
+    |   |--IDENT -> methodFallThruC2 [320:8]
+    |   |--LPAREN -> ( [320:24]
+    |   |--PARAMETERS -> PARAMETERS [320:25]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [320:25]
+    |   |   |   |--MODIFIERS -> MODIFIERS [320:25]
+    |   |   |   |--TYPE -> TYPE [320:25]
+    |   |   |   |   `--LITERAL_INT -> int [320:25]
+    |   |   |   `--IDENT -> i [320:29]
+    |   |   |--COMMA -> , [320:30]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [320:32]
+    |   |   |   |--MODIFIERS -> MODIFIERS [320:32]
+    |   |   |   |--TYPE -> TYPE [320:32]
+    |   |   |   |   `--LITERAL_INT -> int [320:32]
+    |   |   |   `--IDENT -> j [320:36]
+    |   |   |--COMMA -> , [320:37]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [320:39]
+    |   |       |--MODIFIERS -> MODIFIERS [320:39]
+    |   |       |--TYPE -> TYPE [320:39]
+    |   |       |   `--LITERAL_BOOLEAN -> boolean [320:39]
+    |   |       `--IDENT -> cond [320:47]
+    |   |--RPAREN -> ) [320:51]
+    |   `--SLIST -> { [320:53]
+    |       |--LITERAL_WHILE -> while [321:6]
+    |       |   |--LPAREN -> ( [321:12]
+    |       |   |--EXPR -> EXPR [321:13]
+    |       |   |   `--LITERAL_TRUE -> true [321:13]
+    |       |   |--RPAREN -> ) [321:17]
+    |       |   `--SLIST -> { [321:19]
+    |       |       |--LITERAL_SWITCH -> switch [322:10]
+    |       |       |   |--LPAREN -> ( [322:17]
+    |       |       |   |--EXPR -> EXPR [322:18]
+    |       |       |   |   `--IDENT -> i [322:18]
+    |       |       |   |--RPAREN -> ) [322:19]
+    |       |       |   |--LCURLY -> { [322:20]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [323:10]
+    |       |       |   |   |--LITERAL_CASE -> case [323:10]
+    |       |       |   |   |   |--EXPR -> EXPR [323:15]
+    |       |       |   |   |   |   `--NUM_INT -> 0 [323:15]
+    |       |       |   |   |   `--COLON -> : [323:16]
+    |       |       |   |   `--SLIST -> SLIST [324:15]
+    |       |       |   |       |--EXPR -> EXPR [324:15]
+    |       |       |   |       |   `--POST_INC -> ++ [324:15]
+    |       |       |   |       |       `--IDENT -> i [324:14]
+    |       |       |   |       `--SEMI -> ; [324:17]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [326:10]
+    |       |       |   |   |--LITERAL_CASE -> case [326:10]
+    |       |       |   |   |   |--EXPR -> EXPR [326:15]
+    |       |       |   |   |   |   `--NUM_INT -> 1 [326:15]
+    |       |       |   |   |   `--COLON -> : [326:16]
+    |       |       |   |   `--SLIST -> SLIST [327:15]
+    |       |       |   |       |--EXPR -> EXPR [327:15]
+    |       |       |   |       |   `--POST_INC -> ++ [327:15]
+    |       |       |   |       |       `--IDENT -> i [327:14]
+    |       |       |   |       `--SEMI -> ; [327:17]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [329:10]
+    |       |       |   |   |--LITERAL_CASE -> case [329:10]
+    |       |       |   |   |   |--EXPR -> EXPR [329:15]
+    |       |       |   |   |   |   `--NUM_INT -> 2 [329:15]
+    |       |       |   |   |   `--COLON -> : [329:16]
+    |       |       |   |   `--SLIST -> SLIST [330:15]
+    |       |       |   |       |--EXPR -> EXPR [330:15]
+    |       |       |   |       |   `--POST_INC -> ++ [330:15]
+    |       |       |   |       |       `--IDENT -> i [330:14]
+    |       |       |   |       `--SEMI -> ; [330:17]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [331:22]
+    |       |       |   |   |--LITERAL_CASE -> case [331:22]
+    |       |       |   |   |   |--EXPR -> EXPR [331:27]
+    |       |       |   |   |   |   `--NUM_INT -> 3 [331:27]
+    |       |       |   |   |   `--COLON -> : [331:28]
+    |       |       |   |   `--SLIST -> SLIST [332:16]
+    |       |       |   |       `--LITERAL_BREAK -> break [332:16]
+    |       |       |   |           `--SEMI -> ; [332:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [333:10]
+    |       |       |   |   |--LITERAL_CASE -> case [333:10]
+    |       |       |   |   |   |--EXPR -> EXPR [333:15]
+    |       |       |   |   |   |   `--NUM_INT -> 4 [333:15]
+    |       |       |   |   |   `--COLON -> : [333:16]
+    |       |       |   |   `--SLIST -> SLIST [334:15]
+    |       |       |   |       |--EXPR -> EXPR [334:15]
+    |       |       |   |       |   `--POST_INC -> ++ [334:15]
+    |       |       |   |       |       `--IDENT -> i [334:14]
+    |       |       |   |       `--SEMI -> ; [334:17]
+    |       |       |   `--RCURLY -> } [336:10]
+    |       |       `--RCURLY -> } [337:6]
+    |       `--RCURLY -> } [338:3]
+    |--METHOD_DEF -> METHOD_DEF [341:3]
+    |   |--MODIFIERS -> MODIFIERS [341:3]
+    |   |--TYPE -> TYPE [341:3]
+    |   |   `--LITERAL_VOID -> void [341:3]
+    |   |--IDENT -> methodFallThruCOtherWords [341:8]
+    |   |--LPAREN -> ( [341:33]
+    |   |--PARAMETERS -> PARAMETERS [341:34]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [341:34]
+    |   |   |   |--MODIFIERS -> MODIFIERS [341:34]
+    |   |   |   |--TYPE -> TYPE [341:34]
+    |   |   |   |   `--LITERAL_INT -> int [341:34]
+    |   |   |   `--IDENT -> i [341:38]
+    |   |   |--COMMA -> , [341:39]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [341:41]
+    |   |   |   |--MODIFIERS -> MODIFIERS [341:41]
+    |   |   |   |--TYPE -> TYPE [341:41]
+    |   |   |   |   `--LITERAL_INT -> int [341:41]
+    |   |   |   `--IDENT -> j [341:45]
+    |   |   |--COMMA -> , [341:46]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [341:48]
+    |   |       |--MODIFIERS -> MODIFIERS [341:48]
+    |   |       |--TYPE -> TYPE [341:48]
+    |   |       |   `--LITERAL_BOOLEAN -> boolean [341:48]
+    |   |       `--IDENT -> cond [341:56]
+    |   |--RPAREN -> ) [341:60]
+    |   `--SLIST -> { [341:62]
+    |       |--LITERAL_WHILE -> while [342:6]
+    |       |   |--LPAREN -> ( [342:12]
+    |       |   |--EXPR -> EXPR [342:13]
+    |       |   |   `--LITERAL_TRUE -> true [342:13]
+    |       |   |--RPAREN -> ) [342:17]
+    |       |   `--SLIST -> { [342:19]
+    |       |       |--LITERAL_SWITCH -> switch [343:10]
+    |       |       |   |--LPAREN -> ( [343:17]
+    |       |       |   |--EXPR -> EXPR [343:18]
+    |       |       |   |   `--IDENT -> i [343:18]
+    |       |       |   |--RPAREN -> ) [343:19]
+    |       |       |   |--LCURLY -> { [343:20]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [344:10]
+    |       |       |   |   |--LITERAL_CASE -> case [344:10]
+    |       |       |   |   |   |--EXPR -> EXPR [344:15]
+    |       |       |   |   |   |   `--NUM_INT -> 0 [344:15]
+    |       |       |   |   |   `--COLON -> : [344:16]
+    |       |       |   |   `--SLIST -> SLIST [345:15]
+    |       |       |   |       |--EXPR -> EXPR [345:15]
+    |       |       |   |       |   `--POST_INC -> ++ [345:15]
+    |       |       |   |       |       `--IDENT -> i [345:14]
+    |       |       |   |       `--SEMI -> ; [345:17]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [347:10]
+    |       |       |   |   |--LITERAL_CASE -> case [347:10]
+    |       |       |   |   |   |--EXPR -> EXPR [347:15]
+    |       |       |   |   |   |   `--NUM_INT -> 1 [347:15]
+    |       |       |   |   |   `--COLON -> : [347:16]
+    |       |       |   |   `--SLIST -> SLIST [348:15]
+    |       |       |   |       |--EXPR -> EXPR [348:15]
+    |       |       |   |       |   `--POST_INC -> ++ [348:15]
+    |       |       |   |       |       `--IDENT -> i [348:14]
+    |       |       |   |       `--SEMI -> ; [348:17]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [350:10]
+    |       |       |   |   |--LITERAL_CASE -> case [350:10]
+    |       |       |   |   |   |--EXPR -> EXPR [350:15]
+    |       |       |   |   |   |   `--NUM_INT -> 2 [350:15]
+    |       |       |   |   |   `--COLON -> : [350:16]
+    |       |       |   |   `--SLIST -> SLIST [351:15]
+    |       |       |   |       |--EXPR -> EXPR [351:15]
+    |       |       |   |       |   `--POST_INC -> ++ [351:15]
+    |       |       |   |       |       `--IDENT -> i [351:14]
+    |       |       |   |       `--SEMI -> ; [351:17]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [352:29]
+    |       |       |   |   |--LITERAL_CASE -> case [352:29]
+    |       |       |   |   |   |--EXPR -> EXPR [352:34]
+    |       |       |   |   |   |   `--NUM_INT -> 3 [352:34]
+    |       |       |   |   |   `--COLON -> : [352:35]
+    |       |       |   |   `--SLIST -> SLIST [353:16]
+    |       |       |   |       `--LITERAL_BREAK -> break [353:16]
+    |       |       |   |           `--SEMI -> ; [353:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [354:10]
+    |       |       |   |   |--LITERAL_CASE -> case [354:10]
+    |       |       |   |   |   |--EXPR -> EXPR [354:15]
+    |       |       |   |   |   |   `--NUM_INT -> 4 [354:15]
+    |       |       |   |   |   `--COLON -> : [354:16]
+    |       |       |   |   `--SLIST -> SLIST [355:15]
+    |       |       |   |       |--EXPR -> EXPR [355:15]
+    |       |       |   |       |   `--POST_INC -> ++ [355:15]
+    |       |       |   |       |       `--IDENT -> i [355:14]
+    |       |       |   |       `--SEMI -> ; [355:17]
+    |       |       |   `--RCURLY -> } [357:10]
+    |       |       `--RCURLY -> } [358:6]
+    |       `--RCURLY -> } [359:3]
+    |--METHOD_DEF -> METHOD_DEF [362:3]
+    |   |--MODIFIERS -> MODIFIERS [362:3]
+    |   |--TYPE -> TYPE [362:3]
+    |   |   `--LITERAL_VOID -> void [362:3]
+    |   |--IDENT -> methodFallThruCCustomWords [362:8]
+    |   |--LPAREN -> ( [362:34]
+    |   |--PARAMETERS -> PARAMETERS [362:35]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [362:35]
+    |   |   |   |--MODIFIERS -> MODIFIERS [362:35]
+    |   |   |   |--TYPE -> TYPE [362:35]
+    |   |   |   |   `--LITERAL_INT -> int [362:35]
+    |   |   |   `--IDENT -> i [362:39]
+    |   |   |--COMMA -> , [362:40]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [362:42]
+    |   |   |   |--MODIFIERS -> MODIFIERS [362:42]
+    |   |   |   |--TYPE -> TYPE [362:42]
+    |   |   |   |   `--LITERAL_INT -> int [362:42]
+    |   |   |   `--IDENT -> j [362:46]
+    |   |   |--COMMA -> , [362:47]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [362:49]
+    |   |       |--MODIFIERS -> MODIFIERS [362:49]
+    |   |       |--TYPE -> TYPE [362:49]
+    |   |       |   `--LITERAL_BOOLEAN -> boolean [362:49]
+    |   |       `--IDENT -> cond [362:57]
+    |   |--RPAREN -> ) [362:61]
+    |   `--SLIST -> { [362:63]
+    |       |--LITERAL_WHILE -> while [363:6]
+    |       |   |--LPAREN -> ( [363:12]
+    |       |   |--EXPR -> EXPR [363:13]
+    |       |   |   `--LITERAL_TRUE -> true [363:13]
+    |       |   |--RPAREN -> ) [363:17]
+    |       |   `--SLIST -> { [363:19]
+    |       |       |--LITERAL_SWITCH -> switch [364:10]
+    |       |       |   |--LPAREN -> ( [364:17]
+    |       |       |   |--EXPR -> EXPR [364:18]
+    |       |       |   |   `--IDENT -> i [364:18]
+    |       |       |   |--RPAREN -> ) [364:19]
+    |       |       |   |--LCURLY -> { [364:20]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [365:10]
+    |       |       |   |   |--LITERAL_CASE -> case [365:10]
+    |       |       |   |   |   |--EXPR -> EXPR [365:15]
+    |       |       |   |   |   |   `--NUM_INT -> 0 [365:15]
+    |       |       |   |   |   `--COLON -> : [365:16]
+    |       |       |   |   `--SLIST -> SLIST [366:15]
+    |       |       |   |       |--EXPR -> EXPR [366:15]
+    |       |       |   |       |   `--POST_INC -> ++ [366:15]
+    |       |       |   |       |       `--IDENT -> i [366:14]
+    |       |       |   |       `--SEMI -> ; [366:17]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [368:10]
+    |       |       |   |   |--LITERAL_CASE -> case [368:10]
+    |       |       |   |   |   |--EXPR -> EXPR [368:15]
+    |       |       |   |   |   |   `--NUM_INT -> 1 [368:15]
+    |       |       |   |   |   `--COLON -> : [368:16]
+    |       |       |   |   `--SLIST -> SLIST [369:15]
+    |       |       |   |       |--EXPR -> EXPR [369:15]
+    |       |       |   |       |   `--POST_INC -> ++ [369:15]
+    |       |       |   |       |       `--IDENT -> i [369:14]
+    |       |       |   |       `--SEMI -> ; [369:17]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [371:10]
+    |       |       |   |   |--LITERAL_CASE -> case [371:10]
+    |       |       |   |   |   |--EXPR -> EXPR [371:15]
+    |       |       |   |   |   |   `--NUM_INT -> 2 [371:15]
+    |       |       |   |   |   `--COLON -> : [371:16]
+    |       |       |   |   `--SLIST -> SLIST [372:15]
+    |       |       |   |       |--EXPR -> EXPR [372:15]
+    |       |       |   |       |   `--POST_INC -> ++ [372:15]
+    |       |       |   |       |       `--IDENT -> i [372:14]
+    |       |       |   |       `--SEMI -> ; [372:17]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [373:39]
+    |       |       |   |   |--LITERAL_CASE -> case [373:39]
+    |       |       |   |   |   |--EXPR -> EXPR [373:44]
+    |       |       |   |   |   |   `--NUM_INT -> 3 [373:44]
+    |       |       |   |   |   `--COLON -> : [373:45]
+    |       |       |   |   `--SLIST -> SLIST [374:16]
+    |       |       |   |       `--LITERAL_BREAK -> break [374:16]
+    |       |       |   |           `--SEMI -> ; [374:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [375:10]
+    |       |       |   |   |--LITERAL_CASE -> case [375:10]
+    |       |       |   |   |   |--EXPR -> EXPR [375:15]
+    |       |       |   |   |   |   `--NUM_INT -> 4 [375:15]
+    |       |       |   |   |   `--COLON -> : [375:16]
+    |       |       |   |   `--SLIST -> SLIST [376:15]
+    |       |       |   |       |--EXPR -> EXPR [376:15]
+    |       |       |   |       |   `--POST_INC -> ++ [376:15]
+    |       |       |   |       |       `--IDENT -> i [376:14]
+    |       |       |   |       `--SEMI -> ; [376:17]
+    |       |       |   `--RCURLY -> } [378:10]
+    |       |       `--RCURLY -> } [379:6]
+    |       `--RCURLY -> } [380:3]
+    |--METHOD_DEF -> METHOD_DEF [382:3]
+    |   |--MODIFIERS -> MODIFIERS [382:3]
+    |   |--TYPE -> TYPE [382:3]
+    |   |   `--LITERAL_VOID -> void [382:3]
+    |   |--IDENT -> methodFallThruLastCaseGroup [382:8]
+    |   |--LPAREN -> ( [382:35]
+    |   |--PARAMETERS -> PARAMETERS [382:36]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [382:36]
+    |   |   |   |--MODIFIERS -> MODIFIERS [382:36]
+    |   |   |   |--TYPE -> TYPE [382:36]
+    |   |   |   |   `--LITERAL_INT -> int [382:36]
+    |   |   |   `--IDENT -> i [382:40]
+    |   |   |--COMMA -> , [382:41]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [382:43]
+    |   |   |   |--MODIFIERS -> MODIFIERS [382:43]
+    |   |   |   |--TYPE -> TYPE [382:43]
+    |   |   |   |   `--LITERAL_INT -> int [382:43]
+    |   |   |   `--IDENT -> j [382:47]
+    |   |   |--COMMA -> , [382:48]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [382:50]
+    |   |       |--MODIFIERS -> MODIFIERS [382:50]
+    |   |       |--TYPE -> TYPE [382:50]
+    |   |       |   `--LITERAL_BOOLEAN -> boolean [382:50]
+    |   |       `--IDENT -> cond [382:58]
+    |   |--RPAREN -> ) [382:62]
+    |   `--SLIST -> { [382:64]
+    |       |--LITERAL_WHILE -> while [383:7]
+    |       |   |--LPAREN -> ( [383:13]
+    |       |   |--EXPR -> EXPR [383:14]
+    |       |   |   `--LITERAL_TRUE -> true [383:14]
+    |       |   |--RPAREN -> ) [383:18]
+    |       |   `--SLIST -> { [383:20]
+    |       |       |--LITERAL_SWITCH -> switch [384:11]
+    |       |       |   |--LPAREN -> ( [384:18]
+    |       |       |   |--EXPR -> EXPR [384:19]
+    |       |       |   |   `--IDENT -> i [384:19]
+    |       |       |   |--RPAREN -> ) [384:20]
+    |       |       |   |--LCURLY -> { [384:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [385:11]
+    |       |       |   |   |--LITERAL_CASE -> case [385:11]
+    |       |       |   |   |   |--EXPR -> EXPR [385:16]
+    |       |       |   |   |   |   `--NUM_INT -> 0 [385:16]
+    |       |       |   |   |   `--COLON -> : [385:17]
+    |       |       |   |   `--SLIST -> SLIST [386:16]
+    |       |       |   |       |--EXPR -> EXPR [386:16]
+    |       |       |   |       |   `--POST_INC -> ++ [386:16]
+    |       |       |   |       |       `--IDENT -> i [386:15]
+    |       |       |   |       `--SEMI -> ; [386:18]
+    |       |       |   `--RCURLY -> } [387:11]
+    |       |       |--LITERAL_SWITCH -> switch [388:11]
+    |       |       |   |--LPAREN -> ( [388:18]
+    |       |       |   |--EXPR -> EXPR [388:19]
+    |       |       |   |   `--IDENT -> i [388:19]
+    |       |       |   |--RPAREN -> ) [388:20]
+    |       |       |   |--LCURLY -> { [388:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [389:11]
+    |       |       |   |   |--LITERAL_CASE -> case [389:11]
+    |       |       |   |   |   |--EXPR -> EXPR [389:16]
+    |       |       |   |   |   |   `--NUM_INT -> 0 [389:16]
+    |       |       |   |   |   `--COLON -> : [389:17]
+    |       |       |   |   `--SLIST -> SLIST [390:16]
+    |       |       |   |       |--EXPR -> EXPR [390:16]
+    |       |       |   |       |   `--POST_INC -> ++ [390:16]
+    |       |       |   |       |       `--IDENT -> i [390:15]
+    |       |       |   |       `--SEMI -> ; [390:18]
+    |       |       |   `--RCURLY -> } [392:11]
+    |       |       |--LITERAL_SWITCH -> switch [393:11]
+    |       |       |   |--LPAREN -> ( [393:18]
+    |       |       |   |--EXPR -> EXPR [393:19]
+    |       |       |   |   `--IDENT -> i [393:19]
+    |       |       |   |--RPAREN -> ) [393:20]
+    |       |       |   |--LCURLY -> { [393:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [394:11]
+    |       |       |   |   |--LITERAL_CASE -> case [394:11]
+    |       |       |   |   |   |--EXPR -> EXPR [394:16]
+    |       |       |   |   |   |   `--NUM_INT -> 0 [394:16]
+    |       |       |   |   |   `--COLON -> : [394:17]
+    |       |       |   |   `--SLIST -> SLIST [395:16]
+    |       |       |   |       |--EXPR -> EXPR [395:16]
+    |       |       |   |       |   `--POST_INC -> ++ [395:16]
+    |       |       |   |       |       `--IDENT -> i [395:15]
+    |       |       |   |       `--SEMI -> ; [395:18]
+    |       |       |   `--RCURLY -> } [396:26]
+    |       |       `--RCURLY -> } [397:7]
+    |       `--RCURLY -> } [398:4]
+    |--METHOD_DEF -> METHOD_DEF [400:4]
+    |   |--MODIFIERS -> MODIFIERS [400:4]
+    |   |--TYPE -> TYPE [400:4]
+    |   |   `--LITERAL_VOID -> void [400:4]
+    |   |--IDENT -> method1472228 [400:9]
+    |   |--LPAREN -> ( [400:22]
+    |   |--PARAMETERS -> PARAMETERS [400:23]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [400:23]
+    |   |       |--MODIFIERS -> MODIFIERS [400:23]
+    |   |       |--TYPE -> TYPE [400:23]
+    |   |       |   `--LITERAL_INT -> int [400:23]
+    |   |       `--IDENT -> i [400:27]
+    |   |--RPAREN -> ) [400:28]
+    |   `--SLIST -> { [400:30]
+    |       |--LITERAL_SWITCH -> switch [401:8]
+    |       |   |--LPAREN -> ( [401:14]
+    |       |   |--EXPR -> EXPR [401:15]
+    |       |   |   `--IDENT -> i [401:15]
+    |       |   |--RPAREN -> ) [401:16]
+    |       |   |--LCURLY -> { [401:18]
+    |       |   |--CASE_GROUP -> CASE_GROUP [402:8]
+    |       |   |   |--LITERAL_CASE -> case [402:8]
+    |       |   |   |   |--EXPR -> EXPR [402:13]
+    |       |   |   |   |   `--NUM_INT -> 2 [402:13]
+    |       |   |   |   `--COLON -> : [402:14]
+    |       |   |   `--SLIST -> SLIST [404:12]
+    |       |   |       `--LITERAL_BREAK -> break [404:12]
+    |       |   |           `--SEMI -> ; [404:17]
+    |       |   |--CASE_GROUP -> CASE_GROUP [405:8]
+    |       |   |   `--LITERAL_DEFAULT -> default [405:8]
+    |       |   |       `--COLON -> : [405:15]
+    |       |   `--RCURLY -> } [406:8]
+    |       `--RCURLY -> } [407:4]
+    |--METHOD_DEF -> METHOD_DEF [409:4]
+    |   |--MODIFIERS -> MODIFIERS [409:4]
+    |   |--TYPE -> TYPE [409:4]
+    |   |   `--LITERAL_VOID -> void [409:4]
+    |   |--IDENT -> nestedSwitches [409:9]
+    |   |--LPAREN -> ( [409:23]
+    |   |--PARAMETERS -> PARAMETERS [409:24]
+    |   |--RPAREN -> ) [409:24]
+    |   `--SLIST -> { [409:26]
+    |       |--LITERAL_SWITCH -> switch [410:8]
+    |       |   |--LPAREN -> ( [410:15]
+    |       |   |--EXPR -> EXPR [410:24]
+    |       |   |   `--METHOD_CALL -> ( [410:24]
+    |       |   |       |--IDENT -> hashCode [410:16]
+    |       |   |       |--ELIST -> ELIST [410:25]
+    |       |   |       `--RPAREN -> ) [410:25]
+    |       |   |--RPAREN -> ) [410:26]
+    |       |   |--LCURLY -> { [410:28]
+    |       |   |--CASE_GROUP -> CASE_GROUP [411:12]
+    |       |   |   |--LITERAL_CASE -> case [411:12]
+    |       |   |   |   |--EXPR -> EXPR [411:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [411:17]
+    |       |   |   |   `--COLON -> : [411:18]
+    |       |   |   `--SLIST -> SLIST [412:16]
+    |       |   |       `--LITERAL_SWITCH -> switch [412:16]
+    |       |   |           |--LPAREN -> ( [412:23]
+    |       |   |           |--EXPR -> EXPR [412:32]
+    |       |   |           |   `--METHOD_CALL -> ( [412:32]
+    |       |   |           |       |--IDENT -> hashCode [412:24]
+    |       |   |           |       |--ELIST -> ELIST [412:33]
+    |       |   |           |       `--RPAREN -> ) [412:33]
+    |       |   |           |--RPAREN -> ) [412:34]
+    |       |   |           |--LCURLY -> { [412:36]
+    |       |   |           |--CASE_GROUP -> CASE_GROUP [413:20]
+    |       |   |           |   `--LITERAL_CASE -> case [413:20]
+    |       |   |           |       |--EXPR -> EXPR [413:25]
+    |       |   |           |       |   `--NUM_INT -> 1 [413:25]
+    |       |   |           |       `--COLON -> : [413:26]
+    |       |   |           `--RCURLY -> } [414:16]
+    |       |   |--CASE_GROUP -> CASE_GROUP [415:12]
+    |       |   |   `--LITERAL_DEFAULT -> default [415:12]
+    |       |   |       `--COLON -> : [415:19]
+    |       |   `--RCURLY -> } [416:8]
+    |       `--RCURLY -> } [417:4]
+    |--METHOD_DEF -> METHOD_DEF [419:4]
+    |   |--MODIFIERS -> MODIFIERS [419:4]
+    |   |--TYPE -> TYPE [419:4]
+    |   |   `--LITERAL_VOID -> void [419:4]
+    |   |--IDENT -> nextedSwitches2 [419:9]
+    |   |--LPAREN -> ( [419:24]
+    |   |--PARAMETERS -> PARAMETERS [419:25]
+    |   |--RPAREN -> ) [419:25]
+    |   `--SLIST -> { [419:27]
+    |       |--LITERAL_SWITCH -> switch [420:8]
+    |       |   |--LPAREN -> ( [420:14]
+    |       |   |--EXPR -> EXPR [420:23]
+    |       |   |   `--METHOD_CALL -> ( [420:23]
+    |       |   |       |--IDENT -> hashCode [420:15]
+    |       |   |       |--ELIST -> ELIST [420:24]
+    |       |   |       `--RPAREN -> ) [420:24]
+    |       |   |--RPAREN -> ) [420:25]
+    |       |   |--LCURLY -> { [420:27]
+    |       |   |--CASE_GROUP -> CASE_GROUP [421:8]
+    |       |   |   |--LITERAL_CASE -> case [421:8]
+    |       |   |   |   |--EXPR -> EXPR [421:13]
+    |       |   |   |   |   `--NUM_INT -> 1 [421:13]
+    |       |   |   |   `--COLON -> : [421:14]
+    |       |   |   `--SLIST -> SLIST [422:12]
+    |       |   |       `--LITERAL_SWITCH -> switch [422:12]
+    |       |   |           |--LPAREN -> ( [422:18]
+    |       |   |           |--EXPR -> EXPR [422:27]
+    |       |   |           |   `--METHOD_CALL -> ( [422:27]
+    |       |   |           |       |--IDENT -> hashCode [422:19]
+    |       |   |           |       |--ELIST -> ELIST [422:28]
+    |       |   |           |       `--RPAREN -> ) [422:28]
+    |       |   |           |--RPAREN -> ) [422:29]
+    |       |   |           |--LCURLY -> { [422:30]
+    |       |   |           `--RCURLY -> } [422:31]
+    |       |   |--CASE_GROUP -> CASE_GROUP [423:8]
+    |       |   |   |--LITERAL_CASE -> case [423:8]
+    |       |   |   |   |--EXPR -> EXPR [423:13]
+    |       |   |   |   |   `--NUM_INT -> 2 [423:13]
+    |       |   |   |   `--COLON -> : [423:14]
+    |       |   |   `--SLIST -> SLIST [424:32]
+    |       |   |       |--EXPR -> EXPR [424:32]
+    |       |   |       |   `--METHOD_CALL -> ( [424:32]
+    |       |   |       |       |--DOT -> . [424:18]
+    |       |   |       |       |   |--IDENT -> System [424:12]
+    |       |   |       |       |   `--IDENT -> lineSeparator [424:19]
+    |       |   |       |       |--ELIST -> ELIST [424:33]
+    |       |   |       |       `--RPAREN -> ) [424:33]
+    |       |   |       |--SEMI -> ; [424:34]
+    |       |   |       `--LITERAL_BREAK -> break [425:12]
+    |       |   |           `--SEMI -> ; [425:17]
+    |       |   `--RCURLY -> } [426:8]
+    |       `--RCURLY -> } [427:4]
+    |--METHOD_DEF -> METHOD_DEF [429:4]
+    |   |--MODIFIERS -> MODIFIERS [429:4]
+    |   |--TYPE -> TYPE [429:4]
+    |   |   `--LITERAL_VOID -> void [429:4]
+    |   |--IDENT -> ifWithoutBreak [429:9]
+    |   |--LPAREN -> ( [429:23]
+    |   |--PARAMETERS -> PARAMETERS [429:24]
+    |   |--RPAREN -> ) [429:24]
+    |   `--SLIST -> { [429:26]
+    |       |--LITERAL_SWITCH -> switch [430:8]
+    |       |   |--LPAREN -> ( [430:14]
+    |       |   |--EXPR -> EXPR [430:23]
+    |       |   |   `--METHOD_CALL -> ( [430:23]
+    |       |   |       |--IDENT -> hashCode [430:15]
+    |       |   |       |--ELIST -> ELIST [430:24]
+    |       |   |       `--RPAREN -> ) [430:24]
+    |       |   |--RPAREN -> ) [430:25]
+    |       |   |--LCURLY -> { [430:27]
+    |       |   |--CASE_GROUP -> CASE_GROUP [431:8]
+    |       |   |   |--LITERAL_CASE -> case [431:8]
+    |       |   |   |   |--EXPR -> EXPR [431:13]
+    |       |   |   |   |   `--NUM_INT -> 1 [431:13]
+    |       |   |   |   `--COLON -> : [431:14]
+    |       |   |   `--SLIST -> SLIST [432:12]
+    |       |   |       `--LITERAL_IF -> if [432:12]
+    |       |   |           |--LPAREN -> ( [432:15]
+    |       |   |           |--EXPR -> EXPR [432:16]
+    |       |   |           |   `--LITERAL_TRUE -> true [432:16]
+    |       |   |           |--RPAREN -> ) [432:20]
+    |       |   |           `--SLIST -> { [432:22]
+    |       |   |               |--EXPR -> EXPR [433:36]
+    |       |   |               |   `--METHOD_CALL -> ( [433:36]
+    |       |   |               |       |--DOT -> . [433:22]
+    |       |   |               |       |   |--IDENT -> System [433:16]
+    |       |   |               |       |   `--IDENT -> lineSeparator [433:23]
+    |       |   |               |       |--ELIST -> ELIST [433:37]
+    |       |   |               |       `--RPAREN -> ) [433:37]
+    |       |   |               |--SEMI -> ; [433:38]
+    |       |   |               `--RCURLY -> } [434:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [435:8]
+    |       |   |   |--LITERAL_CASE -> case [435:8]
+    |       |   |   |   |--EXPR -> EXPR [435:13]
+    |       |   |   |   |   `--NUM_INT -> 2 [435:13]
+    |       |   |   |   `--COLON -> : [435:14]
+    |       |   |   `--SLIST -> SLIST [436:32]
+    |       |   |       |--EXPR -> EXPR [436:32]
+    |       |   |       |   `--METHOD_CALL -> ( [436:32]
+    |       |   |       |       |--DOT -> . [436:18]
+    |       |   |       |       |   |--IDENT -> System [436:12]
+    |       |   |       |       |   `--IDENT -> lineSeparator [436:19]
+    |       |   |       |       |--ELIST -> ELIST [436:33]
+    |       |   |       |       `--RPAREN -> ) [436:33]
+    |       |   |       |--SEMI -> ; [436:34]
+    |       |   |       `--LITERAL_BREAK -> break [437:12]
+    |       |   |           `--SEMI -> ; [437:17]
+    |       |   `--RCURLY -> } [438:8]
+    |       `--RCURLY -> } [439:4]
+    |--METHOD_DEF -> METHOD_DEF [441:4]
+    |   |--MODIFIERS -> MODIFIERS [441:4]
+    |   |--TYPE -> TYPE [441:4]
+    |   |   `--LITERAL_VOID -> void [441:4]
+    |   |--IDENT -> noCommentAtTheEnd [441:9]
+    |   |--LPAREN -> ( [441:26]
+    |   |--PARAMETERS -> PARAMETERS [441:27]
+    |   |--RPAREN -> ) [441:27]
+    |   `--SLIST -> { [441:29]
+    |       |--LITERAL_SWITCH -> switch [442:8]
+    |       |   |--LPAREN -> ( [442:14]
+    |       |   |--EXPR -> EXPR [442:23]
+    |       |   |   `--METHOD_CALL -> ( [442:23]
+    |       |   |       |--IDENT -> hashCode [442:15]
+    |       |   |       |--ELIST -> ELIST [442:24]
+    |       |   |       `--RPAREN -> ) [442:24]
+    |       |   |--RPAREN -> ) [442:25]
+    |       |   |--LCURLY -> { [442:27]
+    |       |   |--CASE_GROUP -> CASE_GROUP [443:8]
+    |       |   |   |--LITERAL_CASE -> case [443:8]
+    |       |   |   |   |--EXPR -> EXPR [443:13]
+    |       |   |   |   |   `--NUM_INT -> 1 [443:13]
+    |       |   |   |   `--COLON -> : [443:14]
+    |       |   |   `--SLIST -> SLIST [443:36]
+    |       |   |       |--EXPR -> EXPR [443:36]
+    |       |   |       |   `--METHOD_CALL -> ( [443:36]
+    |       |   |       |       |--DOT -> . [443:22]
+    |       |   |       |       |   |--IDENT -> System [443:16]
+    |       |   |       |       |   `--IDENT -> lineSeparator [443:23]
+    |       |   |       |       |--ELIST -> ELIST [443:37]
+    |       |   |       |       `--RPAREN -> ) [443:37]
+    |       |   |       `--SEMI -> ; [443:38]
+    |       |   |--CASE_GROUP -> CASE_GROUP [445:8]
+    |       |   |   |--LITERAL_CASE -> case [445:8]
+    |       |   |   |   |--EXPR -> EXPR [445:13]
+    |       |   |   |   |   `--NUM_INT -> 2 [445:13]
+    |       |   |   |   `--COLON -> : [445:14]
+    |       |   |   `--SLIST -> SLIST [446:32]
+    |       |   |       |--EXPR -> EXPR [446:32]
+    |       |   |       |   `--METHOD_CALL -> ( [446:32]
+    |       |   |       |       |--DOT -> . [446:18]
+    |       |   |       |       |   |--IDENT -> System [446:12]
+    |       |   |       |       |   `--IDENT -> lineSeparator [446:19]
+    |       |   |       |       |--ELIST -> ELIST [446:33]
+    |       |   |       |       `--RPAREN -> ) [446:33]
+    |       |   |       |--SEMI -> ; [446:34]
+    |       |   |       `--LITERAL_BREAK -> break [447:12]
+    |       |   |           `--SEMI -> ; [447:17]
+    |       |   `--RCURLY -> } [448:8]
+    |       `--RCURLY -> } [449:4]
+    |--METHOD_DEF -> METHOD_DEF [451:4]
+    |   |--MODIFIERS -> MODIFIERS [451:4]
+    |   |--TYPE -> TYPE [451:4]
+    |   |   `--LITERAL_VOID -> void [451:4]
+    |   |--IDENT -> synchronizedStatement [451:9]
+    |   |--LPAREN -> ( [451:30]
+    |   |--PARAMETERS -> PARAMETERS [451:31]
+    |   |--RPAREN -> ) [451:31]
+    |   `--SLIST -> { [451:33]
+    |       |--LITERAL_SWITCH -> switch [452:7]
+    |       |   |--LPAREN -> ( [452:14]
+    |       |   |--EXPR -> EXPR [452:23]
+    |       |   |   `--METHOD_CALL -> ( [452:23]
+    |       |   |       |--IDENT -> hashCode [452:15]
+    |       |   |       |--ELIST -> ELIST [452:24]
+    |       |   |       `--RPAREN -> ) [452:24]
+    |       |   |--RPAREN -> ) [452:25]
+    |       |   |--LCURLY -> { [452:27]
+    |       |   |--CASE_GROUP -> CASE_GROUP [453:11]
+    |       |   |   |--LITERAL_CASE -> case [453:11]
+    |       |   |   |   |--EXPR -> EXPR [453:16]
+    |       |   |   |   |   `--NUM_INT -> 1 [453:16]
+    |       |   |   |   `--COLON -> : [453:17]
+    |       |   |   `--SLIST -> SLIST [454:15]
+    |       |   |       `--LITERAL_SYNCHRONIZED -> synchronized [454:15]
+    |       |   |           |--LPAREN -> ( [454:28]
+    |       |   |           |--EXPR -> EXPR [454:29]
+    |       |   |           |   `--LITERAL_THIS -> this [454:29]
+    |       |   |           |--RPAREN -> ) [454:33]
+    |       |   |           `--SLIST -> { [454:35]
+    |       |   |               |--LITERAL_BREAK -> break [455:19]
+    |       |   |               |   `--SEMI -> ; [455:24]
+    |       |   |               `--RCURLY -> } [456:15]
+    |       |   |--CASE_GROUP -> CASE_GROUP [457:11]
+    |       |   |   |--LITERAL_CASE -> case [457:11]
+    |       |   |   |   |--EXPR -> EXPR [457:16]
+    |       |   |   |   |   `--NUM_INT -> 2 [457:16]
+    |       |   |   |   `--COLON -> : [457:17]
+    |       |   |   `--SLIST -> SLIST [459:15]
+    |       |   |       `--LITERAL_IF -> if [459:15]
+    |       |   |           |--LPAREN -> ( [459:18]
+    |       |   |           |--EXPR -> EXPR [459:19]
+    |       |   |           |   `--LITERAL_TRUE -> true [459:19]
+    |       |   |           |--RPAREN -> ) [459:23]
+    |       |   |           |--SLIST -> { [459:25]
+    |       |   |           |   |--LITERAL_SYNCHRONIZED -> synchronized [460:19]
+    |       |   |           |   |   |--LPAREN -> ( [460:32]
+    |       |   |           |   |   |--EXPR -> EXPR [460:33]
+    |       |   |           |   |   |   `--LITERAL_THIS -> this [460:33]
+    |       |   |           |   |   |--RPAREN -> ) [460:37]
+    |       |   |           |   |   `--SLIST -> { [460:39]
+    |       |   |           |   |       |--LITERAL_BREAK -> break [461:23]
+    |       |   |           |   |       |   `--SEMI -> ; [461:28]
+    |       |   |           |   |       `--RCURLY -> } [462:19]
+    |       |   |           |   `--RCURLY -> } [463:15]
+    |       |   |           `--LITERAL_ELSE -> else [463:17]
+    |       |   |               `--SLIST -> { [463:22]
+    |       |   |                   |--LITERAL_SYNCHRONIZED -> synchronized [464:19]
+    |       |   |                   |   |--LPAREN -> ( [464:32]
+    |       |   |                   |   |--EXPR -> EXPR [464:33]
+    |       |   |                   |   |   `--LITERAL_THIS -> this [464:33]
+    |       |   |                   |   |--RPAREN -> ) [464:37]
+    |       |   |                   |   `--SLIST -> { [464:39]
+    |       |   |                   |       |--LITERAL_BREAK -> break [465:23]
+    |       |   |                   |       |   `--SEMI -> ; [465:28]
+    |       |   |                   |       `--RCURLY -> } [466:19]
+    |       |   |                   `--RCURLY -> } [467:15]
+    |       |   |--CASE_GROUP -> CASE_GROUP [468:11]
+    |       |   |   |--LITERAL_CASE -> case [468:11]
+    |       |   |   |   |--EXPR -> EXPR [468:16]
+    |       |   |   |   |   `--NUM_INT -> 3 [468:16]
+    |       |   |   |   `--COLON -> : [468:17]
+    |       |   |   `--SLIST -> SLIST [469:15]
+    |       |   |       `--LITERAL_SYNCHRONIZED -> synchronized [469:15]
+    |       |   |           |--LPAREN -> ( [469:28]
+    |       |   |           |--EXPR -> EXPR [469:29]
+    |       |   |           |   `--LITERAL_THIS -> this [469:29]
+    |       |   |           |--RPAREN -> ) [469:33]
+    |       |   |           `--SLIST -> { [469:35]
+    |       |   |               `--RCURLY -> } [470:15]
+    |       |   |--CASE_GROUP -> CASE_GROUP [472:11]
+    |       |   |   |--LITERAL_DEFAULT -> default [472:11]
+    |       |   |   |   `--COLON -> : [472:18]
+    |       |   |   `--SLIST -> SLIST [473:15]
+    |       |   |       `--LITERAL_BREAK -> break [473:15]
+    |       |   |           `--SEMI -> ; [473:20]
+    |       |   `--RCURLY -> } [474:7]
+    |       `--RCURLY -> } [475:4]
+    |--METHOD_DEF -> METHOD_DEF [477:4]
+    |   |--MODIFIERS -> MODIFIERS [477:4]
+    |   |--TYPE -> TYPE [477:4]
+    |   |   `--LITERAL_VOID -> void [477:4]
+    |   |--IDENT -> multipleCasesOnOneLine [477:9]
+    |   |--LPAREN -> ( [477:31]
+    |   |--PARAMETERS -> PARAMETERS [477:32]
+    |   |--RPAREN -> ) [477:32]
+    |   `--SLIST -> { [477:34]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [478:8]
+    |       |   |--MODIFIERS -> MODIFIERS [478:8]
+    |       |   |--TYPE -> TYPE [478:8]
+    |       |   |   `--LITERAL_INT -> int [478:8]
+    |       |   |--IDENT -> i [478:12]
+    |       |   `--ASSIGN -> = [478:14]
+    |       |       `--EXPR -> EXPR [478:16]
+    |       |           `--NUM_INT -> 0 [478:16]
+    |       |--SEMI -> ; [478:17]
+    |       |--LITERAL_SWITCH -> switch [479:8]
+    |       |   |--LPAREN -> ( [479:15]
+    |       |   |--EXPR -> EXPR [479:16]
+    |       |   |   `--IDENT -> i [479:16]
+    |       |   |--RPAREN -> ) [479:17]
+    |       |   |--LCURLY -> { [479:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [480:8]
+    |       |   |   |--LITERAL_CASE -> case [480:8]
+    |       |   |   |   |--EXPR -> EXPR [480:13]
+    |       |   |   |   |   `--NUM_INT -> 0 [480:13]
+    |       |   |   |   `--COLON -> : [480:14]
+    |       |   |   |--LITERAL_CASE -> case [480:16]
+    |       |   |   |   |--EXPR -> EXPR [480:21]
+    |       |   |   |   |   `--NUM_INT -> 1 [480:21]
+    |       |   |   |   `--COLON -> : [480:22]
+    |       |   |   `--SLIST -> SLIST [480:26]
+    |       |   |       |--EXPR -> EXPR [480:26]
+    |       |   |       |   `--STAR_ASSIGN -> *= [480:26]
+    |       |   |       |       |--IDENT -> i [480:24]
+    |       |   |       |       `--IDENT -> i [480:29]
+    |       |   |       `--SEMI -> ; [480:30]
+    |       |   |--CASE_GROUP -> CASE_GROUP [481:8]
+    |       |   |   |--LITERAL_CASE -> case [481:8]
+    |       |   |   |   |--EXPR -> EXPR [481:13]
+    |       |   |   |   |   `--NUM_INT -> 2 [481:13]
+    |       |   |   |   `--COLON -> : [481:14]
+    |       |   |   |--LITERAL_CASE -> case [481:16]
+    |       |   |   |   |--EXPR -> EXPR [481:21]
+    |       |   |   |   |   `--NUM_INT -> 3 [481:21]
+    |       |   |   |   `--COLON -> : [481:22]
+    |       |   |   `--SLIST -> SLIST [481:26]
+    |       |   |       |--EXPR -> EXPR [481:26]
+    |       |   |       |   `--STAR_ASSIGN -> *= [481:26]
+    |       |   |       |       |--IDENT -> i [481:24]
+    |       |   |       |       `--IDENT -> i [481:29]
+    |       |   |       `--SEMI -> ; [481:30]
+    |       |   |--CASE_GROUP -> CASE_GROUP [482:8]
+    |       |   |   |--LITERAL_CASE -> case [482:8]
+    |       |   |   |   |--EXPR -> EXPR [482:13]
+    |       |   |   |   |   `--NUM_INT -> 4 [482:13]
+    |       |   |   |   `--COLON -> : [482:14]
+    |       |   |   |--LITERAL_CASE -> case [482:16]
+    |       |   |   |   |--EXPR -> EXPR [482:21]
+    |       |   |   |   |   `--NUM_INT -> 5 [482:21]
+    |       |   |   |   `--COLON -> : [482:22]
+    |       |   |   `--SLIST -> SLIST [482:26]
+    |       |   |       |--EXPR -> EXPR [482:26]
+    |       |   |       |   `--STAR_ASSIGN -> *= [482:26]
+    |       |   |       |       |--IDENT -> i [482:24]
+    |       |   |       |       `--IDENT -> i [482:29]
+    |       |   |       `--SEMI -> ; [482:30]
+    |       |   |--CASE_GROUP -> CASE_GROUP [483:8]
+    |       |   |   |--LITERAL_CASE -> case [483:8]
+    |       |   |   |   |--EXPR -> EXPR [483:13]
+    |       |   |   |   |   `--NUM_INT -> 6 [483:13]
+    |       |   |   |   `--COLON -> : [483:14]
+    |       |   |   |--LITERAL_CASE -> case [483:16]
+    |       |   |   |   |--EXPR -> EXPR [483:21]
+    |       |   |   |   |   `--NUM_INT -> 7 [483:21]
+    |       |   |   |   `--COLON -> : [483:22]
+    |       |   |   `--SLIST -> SLIST [483:26]
+    |       |   |       |--EXPR -> EXPR [483:26]
+    |       |   |       |   `--STAR_ASSIGN -> *= [483:26]
+    |       |   |       |       |--IDENT -> i [483:24]
+    |       |   |       |       `--IDENT -> i [483:29]
+    |       |   |       |--SEMI -> ; [483:30]
+    |       |   |       `--LITERAL_BREAK -> break [484:12]
+    |       |   |           `--SEMI -> ; [484:17]
+    |       |   |--CASE_GROUP -> CASE_GROUP [485:8]
+    |       |   |   |--LITERAL_DEFAULT -> default [485:8]
+    |       |   |   |   `--COLON -> : [485:15]
+    |       |   |   `--SLIST -> SLIST [486:12]
+    |       |   |       `--LITERAL_THROW -> throw [486:12]
+    |       |   |           |--EXPR -> EXPR [486:18]
+    |       |   |           |   `--LITERAL_NEW -> new [486:18]
+    |       |   |           |       |--IDENT -> RuntimeException [486:22]
+    |       |   |           |       |--LPAREN -> ( [486:38]
+    |       |   |           |       |--ELIST -> ELIST [486:39]
+    |       |   |           |       `--RPAREN -> ) [486:39]
+    |       |   |           `--SEMI -> ; [486:40]
+    |       |   `--RCURLY -> } [487:8]
+    |       `--RCURLY -> } [488:4]
+    |--METHOD_DEF -> METHOD_DEF [491:3]
+    |   |--MODIFIERS -> MODIFIERS [491:3]
+    |   |--TYPE -> TYPE [491:3]
+    |   |   `--LITERAL_VOID -> void [491:3]
+    |   |--IDENT -> methodFallThruWithDash [491:8]
+    |   |--LPAREN -> ( [491:30]
+    |   |--PARAMETERS -> PARAMETERS [491:31]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [491:31]
+    |   |   |   |--MODIFIERS -> MODIFIERS [491:31]
+    |   |   |   |--TYPE -> TYPE [491:31]
+    |   |   |   |   `--LITERAL_INT -> int [491:31]
+    |   |   |   `--IDENT -> i [491:35]
+    |   |   |--COMMA -> , [491:36]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [491:38]
+    |   |   |   |--MODIFIERS -> MODIFIERS [491:38]
+    |   |   |   |--TYPE -> TYPE [491:38]
+    |   |   |   |   `--LITERAL_INT -> int [491:38]
+    |   |   |   `--IDENT -> j [491:42]
+    |   |   |--COMMA -> , [491:43]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [491:45]
+    |   |       |--MODIFIERS -> MODIFIERS [491:45]
+    |   |       |--TYPE -> TYPE [491:45]
+    |   |       |   `--LITERAL_BOOLEAN -> boolean [491:45]
+    |   |       `--IDENT -> cond [491:53]
+    |   |--RPAREN -> ) [491:57]
+    |   `--SLIST -> { [491:59]
+    |       |--LITERAL_WHILE -> while [492:6]
+    |       |   |--LPAREN -> ( [492:12]
+    |       |   |--EXPR -> EXPR [492:13]
+    |       |   |   `--LITERAL_TRUE -> true [492:13]
+    |       |   |--RPAREN -> ) [492:17]
+    |       |   `--SLIST -> { [492:19]
+    |       |       |--LITERAL_SWITCH -> switch [493:10]
+    |       |       |   |--LPAREN -> ( [493:17]
+    |       |       |   |--EXPR -> EXPR [493:18]
+    |       |       |   |   `--IDENT -> i [493:18]
+    |       |       |   |--RPAREN -> ) [493:19]
+    |       |       |   |--LCURLY -> { [493:20]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [494:14]
+    |       |       |   |   |--LITERAL_CASE -> case [494:14]
+    |       |       |   |   |   |--EXPR -> EXPR [494:19]
+    |       |       |   |   |   |   `--NUM_INT -> 0 [494:19]
+    |       |       |   |   |   `--COLON -> : [494:20]
+    |       |       |   |   `--SLIST -> SLIST [495:19]
+    |       |       |   |       |--EXPR -> EXPR [495:19]
+    |       |       |   |       |   `--POST_INC -> ++ [495:19]
+    |       |       |   |       |       `--IDENT -> i [495:18]
+    |       |       |   |       `--SEMI -> ; [495:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [496:14]
+    |       |       |   |   |--LITERAL_CASE -> case [496:14]
+    |       |       |   |   |   |--EXPR -> EXPR [496:19]
+    |       |       |   |   |   |   `--NUM_INT -> 1 [496:19]
+    |       |       |   |   |   `--COLON -> : [496:20]
+    |       |       |   |   `--SLIST -> SLIST [497:19]
+    |       |       |   |       |--EXPR -> EXPR [497:19]
+    |       |       |   |       |   `--POST_INC -> ++ [497:19]
+    |       |       |   |       |       `--IDENT -> i [497:18]
+    |       |       |   |       `--SEMI -> ; [497:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [498:14]
+    |       |       |   |   |--LITERAL_CASE -> case [498:14]
+    |       |       |   |   |   |--EXPR -> EXPR [498:19]
+    |       |       |   |   |   |   `--NUM_INT -> 2 [498:19]
+    |       |       |   |   |   `--COLON -> : [498:20]
+    |       |       |   |   `--SLIST -> SLIST [499:19]
+    |       |       |   |       |--EXPR -> EXPR [499:19]
+    |       |       |   |       |   `--POST_INC -> ++ [499:19]
+    |       |       |   |       |       `--IDENT -> i [499:18]
+    |       |       |   |       `--SEMI -> ; [499:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [500:14]
+    |       |       |   |   |--LITERAL_CASE -> case [500:14]
+    |       |       |   |   |   |--EXPR -> EXPR [500:19]
+    |       |       |   |   |   |   `--NUM_INT -> 3 [500:19]
+    |       |       |   |   |   `--COLON -> : [500:20]
+    |       |       |   |   `--SLIST -> SLIST [501:19]
+    |       |       |   |       |--EXPR -> EXPR [501:19]
+    |       |       |   |       |   `--POST_INC -> ++ [501:19]
+    |       |       |   |       |       `--IDENT -> i [501:18]
+    |       |       |   |       `--SEMI -> ; [501:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [502:14]
+    |       |       |   |   |--LITERAL_CASE -> case [502:14]
+    |       |       |   |   |   |--EXPR -> EXPR [502:19]
+    |       |       |   |   |   |   `--NUM_INT -> 4 [502:19]
+    |       |       |   |   |   `--COLON -> : [502:20]
+    |       |       |   |   `--SLIST -> SLIST [503:19]
+    |       |       |   |       |--EXPR -> EXPR [503:19]
+    |       |       |   |       |   `--POST_INC -> ++ [503:19]
+    |       |       |   |       |       `--IDENT -> i [503:18]
+    |       |       |   |       `--SEMI -> ; [503:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [504:14]
+    |       |       |   |   |--LITERAL_CASE -> case [504:14]
+    |       |       |   |   |   |--EXPR -> EXPR [504:19]
+    |       |       |   |   |   |   `--NUM_INT -> 5 [504:19]
+    |       |       |   |   |   `--COLON -> : [504:20]
+    |       |       |   |   `--SLIST -> SLIST [505:19]
+    |       |       |   |       |--EXPR -> EXPR [505:19]
+    |       |       |   |       |   `--POST_INC -> ++ [505:19]
+    |       |       |   |       |       `--IDENT -> i [505:18]
+    |       |       |   |       `--SEMI -> ; [505:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [506:14]
+    |       |       |   |   |--LITERAL_CASE -> case [506:14]
+    |       |       |   |   |   |--EXPR -> EXPR [506:19]
+    |       |       |   |   |   |   `--NUM_INT -> 6 [506:19]
+    |       |       |   |   |   `--COLON -> : [506:20]
+    |       |       |   |   `--SLIST -> SLIST [507:19]
+    |       |       |   |       |--EXPR -> EXPR [507:19]
+    |       |       |   |       |   `--POST_INC -> ++ [507:19]
+    |       |       |   |       |       `--IDENT -> i [507:18]
+    |       |       |   |       `--SEMI -> ; [507:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [508:14]
+    |       |       |   |   |--LITERAL_CASE -> case [508:14]
+    |       |       |   |   |   |--EXPR -> EXPR [508:19]
+    |       |       |   |   |   |   `--NUM_INT -> 7 [508:19]
+    |       |       |   |   |   `--COLON -> : [508:20]
+    |       |       |   |   `--SLIST -> SLIST [509:19]
+    |       |       |   |       |--EXPR -> EXPR [509:19]
+    |       |       |   |       |   `--POST_INC -> ++ [509:19]
+    |       |       |   |       |       `--IDENT -> i [509:18]
+    |       |       |   |       `--SEMI -> ; [509:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [510:14]
+    |       |       |   |   |--LITERAL_CASE -> case [510:14]
+    |       |       |   |   |   |--EXPR -> EXPR [510:19]
+    |       |       |   |   |   |   `--NUM_INT -> 8 [510:19]
+    |       |       |   |   |   `--COLON -> : [510:20]
+    |       |       |   |   `--SLIST -> SLIST [511:19]
+    |       |       |   |       |--EXPR -> EXPR [511:19]
+    |       |       |   |       |   `--POST_INC -> ++ [511:19]
+    |       |       |   |       |       `--IDENT -> i [511:18]
+    |       |       |   |       `--SEMI -> ; [511:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [512:14]
+    |       |       |   |   |--LITERAL_CASE -> case [512:14]
+    |       |       |   |   |   |--EXPR -> EXPR [512:19]
+    |       |       |   |   |   |   `--NUM_INT -> 9 [512:19]
+    |       |       |   |   |   `--COLON -> : [512:20]
+    |       |       |   |   `--SLIST -> SLIST [513:19]
+    |       |       |   |       |--EXPR -> EXPR [513:19]
+    |       |       |   |       |   `--POST_INC -> ++ [513:19]
+    |       |       |   |       |       `--IDENT -> i [513:18]
+    |       |       |   |       `--SEMI -> ; [513:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [514:14]
+    |       |       |   |   |--LITERAL_CASE -> case [514:14]
+    |       |       |   |   |   |--EXPR -> EXPR [514:19]
+    |       |       |   |   |   |   `--NUM_INT -> 10 [514:19]
+    |       |       |   |   |   `--COLON -> : [514:21]
+    |       |       |   |   `--SLIST -> SLIST [515:19]
+    |       |       |   |       |--EXPR -> EXPR [515:19]
+    |       |       |   |       |   `--POST_INC -> ++ [515:19]
+    |       |       |   |       |       `--IDENT -> i [515:18]
+    |       |       |   |       `--SEMI -> ; [515:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [516:14]
+    |       |       |   |   |--LITERAL_CASE -> case [516:14]
+    |       |       |   |   |   |--EXPR -> EXPR [516:19]
+    |       |       |   |   |   |   `--NUM_INT -> 11 [516:19]
+    |       |       |   |   |   `--COLON -> : [516:21]
+    |       |       |   |   `--SLIST -> SLIST [517:19]
+    |       |       |   |       |--EXPR -> EXPR [517:19]
+    |       |       |   |       |   `--POST_INC -> ++ [517:19]
+    |       |       |   |       |       `--IDENT -> i [517:18]
+    |       |       |   |       `--SEMI -> ; [517:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [518:14]
+    |       |       |   |   |--LITERAL_CASE -> case [518:14]
+    |       |       |   |   |   |--EXPR -> EXPR [518:19]
+    |       |       |   |   |   |   `--NUM_INT -> 12 [518:19]
+    |       |       |   |   |   `--COLON -> : [518:21]
+    |       |       |   |   `--SLIST -> SLIST [519:19]
+    |       |       |   |       |--EXPR -> EXPR [519:19]
+    |       |       |   |       |   `--POST_INC -> ++ [519:19]
+    |       |       |   |       |       `--IDENT -> i [519:18]
+    |       |       |   |       `--SEMI -> ; [519:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [520:14]
+    |       |       |   |   |--LITERAL_CASE -> case [520:14]
+    |       |       |   |   |   |--EXPR -> EXPR [520:19]
+    |       |       |   |   |   |   `--NUM_INT -> 13 [520:19]
+    |       |       |   |   |   `--COLON -> : [520:21]
+    |       |       |   |   `--SLIST -> SLIST [521:19]
+    |       |       |   |       |--EXPR -> EXPR [521:19]
+    |       |       |   |       |   `--POST_INC -> ++ [521:19]
+    |       |       |   |       |       `--IDENT -> i [521:18]
+    |       |       |   |       `--SEMI -> ; [521:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [522:14]
+    |       |       |   |   |--LITERAL_CASE -> case [522:14]
+    |       |       |   |   |   |--EXPR -> EXPR [522:19]
+    |       |       |   |   |   |   `--NUM_INT -> 14 [522:19]
+    |       |       |   |   |   `--COLON -> : [522:21]
+    |       |       |   |   `--SLIST -> SLIST [523:19]
+    |       |       |   |       |--EXPR -> EXPR [523:19]
+    |       |       |   |       |   `--POST_INC -> ++ [523:19]
+    |       |       |   |       |       `--IDENT -> i [523:18]
+    |       |       |   |       `--SEMI -> ; [523:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [524:14]
+    |       |       |   |   |--LITERAL_CASE -> case [524:14]
+    |       |       |   |   |   |--EXPR -> EXPR [524:19]
+    |       |       |   |   |   |   `--NUM_INT -> 15 [524:19]
+    |       |       |   |   |   `--COLON -> : [524:21]
+    |       |       |   |   `--SLIST -> SLIST [525:19]
+    |       |       |   |       |--EXPR -> EXPR [525:19]
+    |       |       |   |       |   `--POST_INC -> ++ [525:19]
+    |       |       |   |       |       `--IDENT -> i [525:18]
+    |       |       |   |       `--SEMI -> ; [525:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [526:14]
+    |       |       |   |   |--LITERAL_CASE -> case [526:14]
+    |       |       |   |   |   |--EXPR -> EXPR [526:19]
+    |       |       |   |   |   |   `--NUM_INT -> 16 [526:19]
+    |       |       |   |   |   `--COLON -> : [526:21]
+    |       |       |   |   `--SLIST -> SLIST [527:19]
+    |       |       |   |       |--EXPR -> EXPR [527:19]
+    |       |       |   |       |   `--POST_INC -> ++ [527:19]
+    |       |       |   |       |       `--IDENT -> i [527:18]
+    |       |       |   |       `--SEMI -> ; [527:21]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [528:14]
+    |       |       |   |   |--LITERAL_DEFAULT -> default [528:14]
+    |       |       |   |   |   `--COLON -> : [528:21]
+    |       |       |   |   `--SLIST -> SLIST [529:18]
+    |       |       |   |       `--LITERAL_THROW -> throw [529:18]
+    |       |       |   |           |--EXPR -> EXPR [529:24]
+    |       |       |   |           |   `--LITERAL_NEW -> new [529:24]
+    |       |       |   |           |       |--IDENT -> RuntimeException [529:28]
+    |       |       |   |           |       |--LPAREN -> ( [529:44]
+    |       |       |   |           |       |--ELIST -> ELIST [529:45]
+    |       |       |   |           |       `--RPAREN -> ) [529:45]
+    |       |       |   |           `--SEMI -> ; [529:46]
+    |       |       |   `--RCURLY -> } [530:10]
+    |       |       `--RCURLY -> } [531:6]
+    |       `--RCURLY -> } [532:3]
+    `--RCURLY -> } [533:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionForLoops.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionForLoops.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionForLoops.java
@@ -0,0 +1,108 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import java.io.Serializable;
+
+public class InputAntlr4AstRegressionForLoops {
+   int k;
+    void method1()
+    {
+        //Violations:
+        for (int i = 0; i < 1; i++) {
+            i++;
+        }
+        for (int i = 0; i < 1; i++) {
+            i = i + 1;
+        }
+        for (int i = 0; i < 1; i++) {
+            for (int j = 0; j < 1; i++) {
+                --i;
+            }
+        }
+        for (int i = 0, j = 0; i < 1; i++) {
+            j++;
+        }
+
+        // Ok:
+        for (int i = 0; i < 1; i++) {
+        }
+        for (int i = 0; i < 1; i++) {
+            int x = i;
+        }
+        for (int i = 0; i < 1; i++) {
+            Serializable s = new Serializable() {
+                int i = 3;
+                void a() {
+                    System.identityHashCode(i++);
+                }
+            };
+        }
+        for (int k = 0; k < 1; k++) {
+            this.k++;
+        }
+
+        String[] sa = {"a", "b"};
+        for(String s:sa) {}
+        for(String s:sa) {
+            s = "new string";
+        }
+        for(int i=0;i < 10;) {
+            i++;
+        }
+        for (int i = 0, l = 0,m=0; l < 10; i++,m=m+2) {
+            l++;
+            m++;
+        }
+        for (int i = 0; i < 10; ) {
+            i = 11;
+        }
+        int w=0;
+        for (int i=0;i<10; java.sql.Date.valueOf(""),this.i++,w++) {
+            i++;
+            w++;
+        }
+        for (int i=0,k=0; i<10 && k < 10; ++i,++k) {
+            i = i + 3;
+            k = k + 4;
+        }
+        for (int i = 0,j = 0 ; i <10; i++) {
+            j++;
+        }
+
+        for (String v : sa) {
+            new NestedClass() {
+                public void method() {}
+            };
+            v = "bad";
+        }
+        for (int i = 0; i < 10; i += 1) {
+            for (i = 7; i < 10; i += 1) {}
+        }
+        for (String name: new String[] {}) {
+        }
+
+        for (i = 0; i < 10; i++) {
+            String name;
+            name = "";
+        }
+        for (int EXPR = 0; EXPR < 1; EXPR++) {
+            for (int j = 0; j < 1; i++) {
+                i++;
+            }
+        }
+    }
+    private int i;
+}
+
+@SuppressWarnings(value = "this previously caused NullPointerException")
+class VariableDeclaredBeforeTheFirstBlockBegins {
+    void foo(String[] requests) {
+        Class mUse4 = java.util.Enumeration[].class;
+        for (String eventDataType : requests) {
+            @SuppressWarnings(value = "this previously caused NullPointerException")
+            String eventData;
+        }
+    }
+}
+abstract class NestedClass {
+    public abstract void method();
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionForLoops.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionForLoops.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionForLoops.txt
@@ -0,0 +1,995 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+IMPORT -> import [3:0]
+|--DOT -> . [3:14]
+|   |--DOT -> . [3:11]
+|   |   |--IDENT -> java [3:7]
+|   |   `--IDENT -> io [3:12]
+|   `--IDENT -> Serializable [3:15]
+`--SEMI -> ; [3:27]
+CLASS_DEF -> CLASS_DEF [5:0]
+|--MODIFIERS -> MODIFIERS [5:0]
+|   `--LITERAL_PUBLIC -> public [5:0]
+|--LITERAL_CLASS -> class [5:7]
+|--IDENT -> InputAntlr4AstRegressionForLoops [5:13]
+`--OBJBLOCK -> OBJBLOCK [5:46]
+    |--LCURLY -> { [5:46]
+    |--VARIABLE_DEF -> VARIABLE_DEF [6:3]
+    |   |--MODIFIERS -> MODIFIERS [6:3]
+    |   |--TYPE -> TYPE [6:3]
+    |   |   `--LITERAL_INT -> int [6:3]
+    |   |--IDENT -> k [6:7]
+    |   `--SEMI -> ; [6:8]
+    |--METHOD_DEF -> METHOD_DEF [7:4]
+    |   |--MODIFIERS -> MODIFIERS [7:4]
+    |   |--TYPE -> TYPE [7:4]
+    |   |   `--LITERAL_VOID -> void [7:4]
+    |   |--IDENT -> method1 [7:9]
+    |   |--LPAREN -> ( [7:16]
+    |   |--PARAMETERS -> PARAMETERS [7:17]
+    |   |--RPAREN -> ) [7:17]
+    |   `--SLIST -> { [8:4]
+    |       |--LITERAL_FOR -> for [10:8]
+    |       |   |--LPAREN -> ( [10:12]
+    |       |   |--FOR_INIT -> FOR_INIT [10:13]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [10:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [10:13]
+    |       |   |       |--TYPE -> TYPE [10:13]
+    |       |   |       |   `--LITERAL_INT -> int [10:13]
+    |       |   |       |--IDENT -> i [10:17]
+    |       |   |       `--ASSIGN -> = [10:19]
+    |       |   |           `--EXPR -> EXPR [10:21]
+    |       |   |               `--NUM_INT -> 0 [10:21]
+    |       |   |--SEMI -> ; [10:22]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [10:26]
+    |       |   |   `--EXPR -> EXPR [10:26]
+    |       |   |       `--LT -> < [10:26]
+    |       |   |           |--IDENT -> i [10:24]
+    |       |   |           `--NUM_INT -> 1 [10:28]
+    |       |   |--SEMI -> ; [10:29]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [10:32]
+    |       |   |   `--ELIST -> ELIST [10:32]
+    |       |   |       `--EXPR -> EXPR [10:32]
+    |       |   |           `--POST_INC -> ++ [10:32]
+    |       |   |               `--IDENT -> i [10:31]
+    |       |   |--RPAREN -> ) [10:34]
+    |       |   `--SLIST -> { [10:36]
+    |       |       |--EXPR -> EXPR [11:13]
+    |       |       |   `--POST_INC -> ++ [11:13]
+    |       |       |       `--IDENT -> i [11:12]
+    |       |       |--SEMI -> ; [11:15]
+    |       |       `--RCURLY -> } [12:8]
+    |       |--LITERAL_FOR -> for [13:8]
+    |       |   |--LPAREN -> ( [13:12]
+    |       |   |--FOR_INIT -> FOR_INIT [13:13]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [13:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [13:13]
+    |       |   |       |--TYPE -> TYPE [13:13]
+    |       |   |       |   `--LITERAL_INT -> int [13:13]
+    |       |   |       |--IDENT -> i [13:17]
+    |       |   |       `--ASSIGN -> = [13:19]
+    |       |   |           `--EXPR -> EXPR [13:21]
+    |       |   |               `--NUM_INT -> 0 [13:21]
+    |       |   |--SEMI -> ; [13:22]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [13:26]
+    |       |   |   `--EXPR -> EXPR [13:26]
+    |       |   |       `--LT -> < [13:26]
+    |       |   |           |--IDENT -> i [13:24]
+    |       |   |           `--NUM_INT -> 1 [13:28]
+    |       |   |--SEMI -> ; [13:29]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [13:32]
+    |       |   |   `--ELIST -> ELIST [13:32]
+    |       |   |       `--EXPR -> EXPR [13:32]
+    |       |   |           `--POST_INC -> ++ [13:32]
+    |       |   |               `--IDENT -> i [13:31]
+    |       |   |--RPAREN -> ) [13:34]
+    |       |   `--SLIST -> { [13:36]
+    |       |       |--EXPR -> EXPR [14:14]
+    |       |       |   `--ASSIGN -> = [14:14]
+    |       |       |       |--IDENT -> i [14:12]
+    |       |       |       `--PLUS -> + [14:18]
+    |       |       |           |--IDENT -> i [14:16]
+    |       |       |           `--NUM_INT -> 1 [14:20]
+    |       |       |--SEMI -> ; [14:21]
+    |       |       `--RCURLY -> } [15:8]
+    |       |--LITERAL_FOR -> for [16:8]
+    |       |   |--LPAREN -> ( [16:12]
+    |       |   |--FOR_INIT -> FOR_INIT [16:13]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [16:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [16:13]
+    |       |   |       |--TYPE -> TYPE [16:13]
+    |       |   |       |   `--LITERAL_INT -> int [16:13]
+    |       |   |       |--IDENT -> i [16:17]
+    |       |   |       `--ASSIGN -> = [16:19]
+    |       |   |           `--EXPR -> EXPR [16:21]
+    |       |   |               `--NUM_INT -> 0 [16:21]
+    |       |   |--SEMI -> ; [16:22]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [16:26]
+    |       |   |   `--EXPR -> EXPR [16:26]
+    |       |   |       `--LT -> < [16:26]
+    |       |   |           |--IDENT -> i [16:24]
+    |       |   |           `--NUM_INT -> 1 [16:28]
+    |       |   |--SEMI -> ; [16:29]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [16:32]
+    |       |   |   `--ELIST -> ELIST [16:32]
+    |       |   |       `--EXPR -> EXPR [16:32]
+    |       |   |           `--POST_INC -> ++ [16:32]
+    |       |   |               `--IDENT -> i [16:31]
+    |       |   |--RPAREN -> ) [16:34]
+    |       |   `--SLIST -> { [16:36]
+    |       |       |--LITERAL_FOR -> for [17:12]
+    |       |       |   |--LPAREN -> ( [17:16]
+    |       |       |   |--FOR_INIT -> FOR_INIT [17:17]
+    |       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [17:17]
+    |       |       |   |       |--MODIFIERS -> MODIFIERS [17:17]
+    |       |       |   |       |--TYPE -> TYPE [17:17]
+    |       |       |   |       |   `--LITERAL_INT -> int [17:17]
+    |       |       |   |       |--IDENT -> j [17:21]
+    |       |       |   |       `--ASSIGN -> = [17:23]
+    |       |       |   |           `--EXPR -> EXPR [17:25]
+    |       |       |   |               `--NUM_INT -> 0 [17:25]
+    |       |       |   |--SEMI -> ; [17:26]
+    |       |       |   |--FOR_CONDITION -> FOR_CONDITION [17:30]
+    |       |       |   |   `--EXPR -> EXPR [17:30]
+    |       |       |   |       `--LT -> < [17:30]
+    |       |       |   |           |--IDENT -> j [17:28]
+    |       |       |   |           `--NUM_INT -> 1 [17:32]
+    |       |       |   |--SEMI -> ; [17:33]
+    |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [17:36]
+    |       |       |   |   `--ELIST -> ELIST [17:36]
+    |       |       |   |       `--EXPR -> EXPR [17:36]
+    |       |       |   |           `--POST_INC -> ++ [17:36]
+    |       |       |   |               `--IDENT -> i [17:35]
+    |       |       |   |--RPAREN -> ) [17:38]
+    |       |       |   `--SLIST -> { [17:40]
+    |       |       |       |--EXPR -> EXPR [18:16]
+    |       |       |       |   `--DEC -> -- [18:16]
+    |       |       |       |       `--IDENT -> i [18:18]
+    |       |       |       |--SEMI -> ; [18:19]
+    |       |       |       `--RCURLY -> } [19:12]
+    |       |       `--RCURLY -> } [20:8]
+    |       |--LITERAL_FOR -> for [21:8]
+    |       |   |--LPAREN -> ( [21:12]
+    |       |   |--FOR_INIT -> FOR_INIT [21:13]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [21:13]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [21:13]
+    |       |   |   |   |--TYPE -> TYPE [21:13]
+    |       |   |   |   |   `--LITERAL_INT -> int [21:13]
+    |       |   |   |   |--IDENT -> i [21:17]
+    |       |   |   |   `--ASSIGN -> = [21:19]
+    |       |   |   |       `--EXPR -> EXPR [21:21]
+    |       |   |   |           `--NUM_INT -> 0 [21:21]
+    |       |   |   |--COMMA -> , [21:22]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [21:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [21:13]
+    |       |   |       |--TYPE -> TYPE [21:13]
+    |       |   |       |   `--LITERAL_INT -> int [21:13]
+    |       |   |       |--IDENT -> j [21:24]
+    |       |   |       `--ASSIGN -> = [21:26]
+    |       |   |           `--EXPR -> EXPR [21:28]
+    |       |   |               `--NUM_INT -> 0 [21:28]
+    |       |   |--SEMI -> ; [21:29]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [21:33]
+    |       |   |   `--EXPR -> EXPR [21:33]
+    |       |   |       `--LT -> < [21:33]
+    |       |   |           |--IDENT -> i [21:31]
+    |       |   |           `--NUM_INT -> 1 [21:35]
+    |       |   |--SEMI -> ; [21:36]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [21:39]
+    |       |   |   `--ELIST -> ELIST [21:39]
+    |       |   |       `--EXPR -> EXPR [21:39]
+    |       |   |           `--POST_INC -> ++ [21:39]
+    |       |   |               `--IDENT -> i [21:38]
+    |       |   |--RPAREN -> ) [21:41]
+    |       |   `--SLIST -> { [21:43]
+    |       |       |--EXPR -> EXPR [22:13]
+    |       |       |   `--POST_INC -> ++ [22:13]
+    |       |       |       `--IDENT -> j [22:12]
+    |       |       |--SEMI -> ; [22:15]
+    |       |       `--RCURLY -> } [23:8]
+    |       |--LITERAL_FOR -> for [26:8]
+    |       |   |--LPAREN -> ( [26:12]
+    |       |   |--FOR_INIT -> FOR_INIT [26:13]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [26:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [26:13]
+    |       |   |       |--TYPE -> TYPE [26:13]
+    |       |   |       |   `--LITERAL_INT -> int [26:13]
+    |       |   |       |--IDENT -> i [26:17]
+    |       |   |       `--ASSIGN -> = [26:19]
+    |       |   |           `--EXPR -> EXPR [26:21]
+    |       |   |               `--NUM_INT -> 0 [26:21]
+    |       |   |--SEMI -> ; [26:22]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [26:26]
+    |       |   |   `--EXPR -> EXPR [26:26]
+    |       |   |       `--LT -> < [26:26]
+    |       |   |           |--IDENT -> i [26:24]
+    |       |   |           `--NUM_INT -> 1 [26:28]
+    |       |   |--SEMI -> ; [26:29]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [26:32]
+    |       |   |   `--ELIST -> ELIST [26:32]
+    |       |   |       `--EXPR -> EXPR [26:32]
+    |       |   |           `--POST_INC -> ++ [26:32]
+    |       |   |               `--IDENT -> i [26:31]
+    |       |   |--RPAREN -> ) [26:34]
+    |       |   `--SLIST -> { [26:36]
+    |       |       `--RCURLY -> } [27:8]
+    |       |--LITERAL_FOR -> for [28:8]
+    |       |   |--LPAREN -> ( [28:12]
+    |       |   |--FOR_INIT -> FOR_INIT [28:13]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [28:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [28:13]
+    |       |   |       |--TYPE -> TYPE [28:13]
+    |       |   |       |   `--LITERAL_INT -> int [28:13]
+    |       |   |       |--IDENT -> i [28:17]
+    |       |   |       `--ASSIGN -> = [28:19]
+    |       |   |           `--EXPR -> EXPR [28:21]
+    |       |   |               `--NUM_INT -> 0 [28:21]
+    |       |   |--SEMI -> ; [28:22]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [28:26]
+    |       |   |   `--EXPR -> EXPR [28:26]
+    |       |   |       `--LT -> < [28:26]
+    |       |   |           |--IDENT -> i [28:24]
+    |       |   |           `--NUM_INT -> 1 [28:28]
+    |       |   |--SEMI -> ; [28:29]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [28:32]
+    |       |   |   `--ELIST -> ELIST [28:32]
+    |       |   |       `--EXPR -> EXPR [28:32]
+    |       |   |           `--POST_INC -> ++ [28:32]
+    |       |   |               `--IDENT -> i [28:31]
+    |       |   |--RPAREN -> ) [28:34]
+    |       |   `--SLIST -> { [28:36]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [29:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [29:12]
+    |       |       |   |--TYPE -> TYPE [29:12]
+    |       |       |   |   `--LITERAL_INT -> int [29:12]
+    |       |       |   |--IDENT -> x [29:16]
+    |       |       |   `--ASSIGN -> = [29:18]
+    |       |       |       `--EXPR -> EXPR [29:20]
+    |       |       |           `--IDENT -> i [29:20]
+    |       |       |--SEMI -> ; [29:21]
+    |       |       `--RCURLY -> } [30:8]
+    |       |--LITERAL_FOR -> for [31:8]
+    |       |   |--LPAREN -> ( [31:12]
+    |       |   |--FOR_INIT -> FOR_INIT [31:13]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [31:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [31:13]
+    |       |   |       |--TYPE -> TYPE [31:13]
+    |       |   |       |   `--LITERAL_INT -> int [31:13]
+    |       |   |       |--IDENT -> i [31:17]
+    |       |   |       `--ASSIGN -> = [31:19]
+    |       |   |           `--EXPR -> EXPR [31:21]
+    |       |   |               `--NUM_INT -> 0 [31:21]
+    |       |   |--SEMI -> ; [31:22]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [31:26]
+    |       |   |   `--EXPR -> EXPR [31:26]
+    |       |   |       `--LT -> < [31:26]
+    |       |   |           |--IDENT -> i [31:24]
+    |       |   |           `--NUM_INT -> 1 [31:28]
+    |       |   |--SEMI -> ; [31:29]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [31:32]
+    |       |   |   `--ELIST -> ELIST [31:32]
+    |       |   |       `--EXPR -> EXPR [31:32]
+    |       |   |           `--POST_INC -> ++ [31:32]
+    |       |   |               `--IDENT -> i [31:31]
+    |       |   |--RPAREN -> ) [31:34]
+    |       |   `--SLIST -> { [31:36]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [32:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [32:12]
+    |       |       |   |--TYPE -> TYPE [32:12]
+    |       |       |   |   `--IDENT -> Serializable [32:12]
+    |       |       |   |--IDENT -> s [32:25]
+    |       |       |   `--ASSIGN -> = [32:27]
+    |       |       |       `--EXPR -> EXPR [32:29]
+    |       |       |           `--LITERAL_NEW -> new [32:29]
+    |       |       |               |--IDENT -> Serializable [32:33]
+    |       |       |               |--LPAREN -> ( [32:45]
+    |       |       |               |--ELIST -> ELIST [32:46]
+    |       |       |               |--RPAREN -> ) [32:46]
+    |       |       |               `--OBJBLOCK -> OBJBLOCK [32:48]
+    |       |       |                   |--LCURLY -> { [32:48]
+    |       |       |                   |--VARIABLE_DEF -> VARIABLE_DEF [33:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [33:16]
+    |       |       |                   |   |--TYPE -> TYPE [33:16]
+    |       |       |                   |   |   `--LITERAL_INT -> int [33:16]
+    |       |       |                   |   |--IDENT -> i [33:20]
+    |       |       |                   |   |--ASSIGN -> = [33:22]
+    |       |       |                   |   |   `--EXPR -> EXPR [33:24]
+    |       |       |                   |   |       `--NUM_INT -> 3 [33:24]
+    |       |       |                   |   `--SEMI -> ; [33:25]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [34:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [34:16]
+    |       |       |                   |   |--TYPE -> TYPE [34:16]
+    |       |       |                   |   |   `--LITERAL_VOID -> void [34:16]
+    |       |       |                   |   |--IDENT -> a [34:21]
+    |       |       |                   |   |--LPAREN -> ( [34:22]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [34:23]
+    |       |       |                   |   |--RPAREN -> ) [34:23]
+    |       |       |                   |   `--SLIST -> { [34:25]
+    |       |       |                   |       |--EXPR -> EXPR [35:43]
+    |       |       |                   |       |   `--METHOD_CALL -> ( [35:43]
+    |       |       |                   |       |       |--DOT -> . [35:26]
+    |       |       |                   |       |       |   |--IDENT -> System [35:20]
+    |       |       |                   |       |       |   `--IDENT -> identityHashCode [35:27]
+    |       |       |                   |       |       |--ELIST -> ELIST [35:45]
+    |       |       |                   |       |       |   `--EXPR -> EXPR [35:45]
+    |       |       |                   |       |       |       `--POST_INC -> ++ [35:45]
+    |       |       |                   |       |       |           `--IDENT -> i [35:44]
+    |       |       |                   |       |       `--RPAREN -> ) [35:47]
+    |       |       |                   |       |--SEMI -> ; [35:48]
+    |       |       |                   |       `--RCURLY -> } [36:16]
+    |       |       |                   `--RCURLY -> } [37:12]
+    |       |       |--SEMI -> ; [37:13]
+    |       |       `--RCURLY -> } [38:8]
+    |       |--LITERAL_FOR -> for [39:8]
+    |       |   |--LPAREN -> ( [39:12]
+    |       |   |--FOR_INIT -> FOR_INIT [39:13]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [39:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [39:13]
+    |       |   |       |--TYPE -> TYPE [39:13]
+    |       |   |       |   `--LITERAL_INT -> int [39:13]
+    |       |   |       |--IDENT -> k [39:17]
+    |       |   |       `--ASSIGN -> = [39:19]
+    |       |   |           `--EXPR -> EXPR [39:21]
+    |       |   |               `--NUM_INT -> 0 [39:21]
+    |       |   |--SEMI -> ; [39:22]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [39:26]
+    |       |   |   `--EXPR -> EXPR [39:26]
+    |       |   |       `--LT -> < [39:26]
+    |       |   |           |--IDENT -> k [39:24]
+    |       |   |           `--NUM_INT -> 1 [39:28]
+    |       |   |--SEMI -> ; [39:29]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [39:32]
+    |       |   |   `--ELIST -> ELIST [39:32]
+    |       |   |       `--EXPR -> EXPR [39:32]
+    |       |   |           `--POST_INC -> ++ [39:32]
+    |       |   |               `--IDENT -> k [39:31]
+    |       |   |--RPAREN -> ) [39:34]
+    |       |   `--SLIST -> { [39:36]
+    |       |       |--EXPR -> EXPR [40:18]
+    |       |       |   `--POST_INC -> ++ [40:18]
+    |       |       |       `--DOT -> . [40:16]
+    |       |       |           |--LITERAL_THIS -> this [40:12]
+    |       |       |           `--IDENT -> k [40:17]
+    |       |       |--SEMI -> ; [40:20]
+    |       |       `--RCURLY -> } [41:8]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [43:8]
+    |       |   |--MODIFIERS -> MODIFIERS [43:8]
+    |       |   |--TYPE -> TYPE [43:8]
+    |       |   |   |--IDENT -> String [43:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [43:14]
+    |       |   |       `--RBRACK -> ] [43:15]
+    |       |   |--IDENT -> sa [43:17]
+    |       |   `--ASSIGN -> = [43:20]
+    |       |       `--ARRAY_INIT -> { [43:22]
+    |       |           |--EXPR -> EXPR [43:23]
+    |       |           |   `--STRING_LITERAL -> "a" [43:23]
+    |       |           |--COMMA -> , [43:26]
+    |       |           |--EXPR -> EXPR [43:28]
+    |       |           |   `--STRING_LITERAL -> "b" [43:28]
+    |       |           `--RCURLY -> } [43:31]
+    |       |--SEMI -> ; [43:32]
+    |       |--LITERAL_FOR -> for [44:8]
+    |       |   |--LPAREN -> ( [44:11]
+    |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [44:12]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [44:12]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [44:12]
+    |       |   |   |   |--TYPE -> TYPE [44:12]
+    |       |   |   |   |   `--IDENT -> String [44:12]
+    |       |   |   |   `--IDENT -> s [44:19]
+    |       |   |   |--COLON -> : [44:20]
+    |       |   |   `--EXPR -> EXPR [44:21]
+    |       |   |       `--IDENT -> sa [44:21]
+    |       |   |--RPAREN -> ) [44:23]
+    |       |   `--SLIST -> { [44:25]
+    |       |       `--RCURLY -> } [44:26]
+    |       |--LITERAL_FOR -> for [45:8]
+    |       |   |--LPAREN -> ( [45:11]
+    |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [45:12]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [45:12]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [45:12]
+    |       |   |   |   |--TYPE -> TYPE [45:12]
+    |       |   |   |   |   `--IDENT -> String [45:12]
+    |       |   |   |   `--IDENT -> s [45:19]
+    |       |   |   |--COLON -> : [45:20]
+    |       |   |   `--EXPR -> EXPR [45:21]
+    |       |   |       `--IDENT -> sa [45:21]
+    |       |   |--RPAREN -> ) [45:23]
+    |       |   `--SLIST -> { [45:25]
+    |       |       |--EXPR -> EXPR [46:14]
+    |       |       |   `--ASSIGN -> = [46:14]
+    |       |       |       |--IDENT -> s [46:12]
+    |       |       |       `--STRING_LITERAL -> "new string" [46:16]
+    |       |       |--SEMI -> ; [46:28]
+    |       |       `--RCURLY -> } [47:8]
+    |       |--LITERAL_FOR -> for [48:8]
+    |       |   |--LPAREN -> ( [48:11]
+    |       |   |--FOR_INIT -> FOR_INIT [48:12]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [48:12]
+    |       |   |       |--MODIFIERS -> MODIFIERS [48:12]
+    |       |   |       |--TYPE -> TYPE [48:12]
+    |       |   |       |   `--LITERAL_INT -> int [48:12]
+    |       |   |       |--IDENT -> i [48:16]
+    |       |   |       `--ASSIGN -> = [48:17]
+    |       |   |           `--EXPR -> EXPR [48:18]
+    |       |   |               `--NUM_INT -> 0 [48:18]
+    |       |   |--SEMI -> ; [48:19]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [48:22]
+    |       |   |   `--EXPR -> EXPR [48:22]
+    |       |   |       `--LT -> < [48:22]
+    |       |   |           |--IDENT -> i [48:20]
+    |       |   |           `--NUM_INT -> 10 [48:24]
+    |       |   |--SEMI -> ; [48:26]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [48:27]
+    |       |   |--RPAREN -> ) [48:27]
+    |       |   `--SLIST -> { [48:29]
+    |       |       |--EXPR -> EXPR [49:13]
+    |       |       |   `--POST_INC -> ++ [49:13]
+    |       |       |       `--IDENT -> i [49:12]
+    |       |       |--SEMI -> ; [49:15]
+    |       |       `--RCURLY -> } [50:8]
+    |       |--LITERAL_FOR -> for [51:8]
+    |       |   |--LPAREN -> ( [51:12]
+    |       |   |--FOR_INIT -> FOR_INIT [51:13]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [51:13]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [51:13]
+    |       |   |   |   |--TYPE -> TYPE [51:13]
+    |       |   |   |   |   `--LITERAL_INT -> int [51:13]
+    |       |   |   |   |--IDENT -> i [51:17]
+    |       |   |   |   `--ASSIGN -> = [51:19]
+    |       |   |   |       `--EXPR -> EXPR [51:21]
+    |       |   |   |           `--NUM_INT -> 0 [51:21]
+    |       |   |   |--COMMA -> , [51:22]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [51:13]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [51:13]
+    |       |   |   |   |--TYPE -> TYPE [51:13]
+    |       |   |   |   |   `--LITERAL_INT -> int [51:13]
+    |       |   |   |   |--IDENT -> l [51:24]
+    |       |   |   |   `--ASSIGN -> = [51:26]
+    |       |   |   |       `--EXPR -> EXPR [51:28]
+    |       |   |   |           `--NUM_INT -> 0 [51:28]
+    |       |   |   |--COMMA -> , [51:29]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [51:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [51:13]
+    |       |   |       |--TYPE -> TYPE [51:13]
+    |       |   |       |   `--LITERAL_INT -> int [51:13]
+    |       |   |       |--IDENT -> m [51:30]
+    |       |   |       `--ASSIGN -> = [51:31]
+    |       |   |           `--EXPR -> EXPR [51:32]
+    |       |   |               `--NUM_INT -> 0 [51:32]
+    |       |   |--SEMI -> ; [51:33]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [51:37]
+    |       |   |   `--EXPR -> EXPR [51:37]
+    |       |   |       `--LT -> < [51:37]
+    |       |   |           |--IDENT -> l [51:35]
+    |       |   |           `--NUM_INT -> 10 [51:39]
+    |       |   |--SEMI -> ; [51:41]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [51:44]
+    |       |   |   `--ELIST -> ELIST [51:44]
+    |       |   |       |--EXPR -> EXPR [51:44]
+    |       |   |       |   `--POST_INC -> ++ [51:44]
+    |       |   |       |       `--IDENT -> i [51:43]
+    |       |   |       |--COMMA -> , [51:46]
+    |       |   |       `--EXPR -> EXPR [51:48]
+    |       |   |           `--ASSIGN -> = [51:48]
+    |       |   |               |--IDENT -> m [51:47]
+    |       |   |               `--PLUS -> + [51:50]
+    |       |   |                   |--IDENT -> m [51:49]
+    |       |   |                   `--NUM_INT -> 2 [51:51]
+    |       |   |--RPAREN -> ) [51:52]
+    |       |   `--SLIST -> { [51:54]
+    |       |       |--EXPR -> EXPR [52:13]
+    |       |       |   `--POST_INC -> ++ [52:13]
+    |       |       |       `--IDENT -> l [52:12]
+    |       |       |--SEMI -> ; [52:15]
+    |       |       |--EXPR -> EXPR [53:13]
+    |       |       |   `--POST_INC -> ++ [53:13]
+    |       |       |       `--IDENT -> m [53:12]
+    |       |       |--SEMI -> ; [53:15]
+    |       |       `--RCURLY -> } [54:8]
+    |       |--LITERAL_FOR -> for [55:8]
+    |       |   |--LPAREN -> ( [55:12]
+    |       |   |--FOR_INIT -> FOR_INIT [55:13]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [55:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [55:13]
+    |       |   |       |--TYPE -> TYPE [55:13]
+    |       |   |       |   `--LITERAL_INT -> int [55:13]
+    |       |   |       |--IDENT -> i [55:17]
+    |       |   |       `--ASSIGN -> = [55:19]
+    |       |   |           `--EXPR -> EXPR [55:21]
+    |       |   |               `--NUM_INT -> 0 [55:21]
+    |       |   |--SEMI -> ; [55:22]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [55:26]
+    |       |   |   `--EXPR -> EXPR [55:26]
+    |       |   |       `--LT -> < [55:26]
+    |       |   |           |--IDENT -> i [55:24]
+    |       |   |           `--NUM_INT -> 10 [55:28]
+    |       |   |--SEMI -> ; [55:30]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [55:32]
+    |       |   |--RPAREN -> ) [55:32]
+    |       |   `--SLIST -> { [55:34]
+    |       |       |--EXPR -> EXPR [56:14]
+    |       |       |   `--ASSIGN -> = [56:14]
+    |       |       |       |--IDENT -> i [56:12]
+    |       |       |       `--NUM_INT -> 11 [56:16]
+    |       |       |--SEMI -> ; [56:18]
+    |       |       `--RCURLY -> } [57:8]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [58:8]
+    |       |   |--MODIFIERS -> MODIFIERS [58:8]
+    |       |   |--TYPE -> TYPE [58:8]
+    |       |   |   `--LITERAL_INT -> int [58:8]
+    |       |   |--IDENT -> w [58:12]
+    |       |   `--ASSIGN -> = [58:13]
+    |       |       `--EXPR -> EXPR [58:14]
+    |       |           `--NUM_INT -> 0 [58:14]
+    |       |--SEMI -> ; [58:15]
+    |       |--LITERAL_FOR -> for [59:8]
+    |       |   |--LPAREN -> ( [59:12]
+    |       |   |--FOR_INIT -> FOR_INIT [59:13]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [59:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [59:13]
+    |       |   |       |--TYPE -> TYPE [59:13]
+    |       |   |       |   `--LITERAL_INT -> int [59:13]
+    |       |   |       |--IDENT -> i [59:17]
+    |       |   |       `--ASSIGN -> = [59:18]
+    |       |   |           `--EXPR -> EXPR [59:19]
+    |       |   |               `--NUM_INT -> 0 [59:19]
+    |       |   |--SEMI -> ; [59:20]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [59:22]
+    |       |   |   `--EXPR -> EXPR [59:22]
+    |       |   |       `--LT -> < [59:22]
+    |       |   |           |--IDENT -> i [59:21]
+    |       |   |           `--NUM_INT -> 10 [59:23]
+    |       |   |--SEMI -> ; [59:25]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [59:48]
+    |       |   |   `--ELIST -> ELIST [59:48]
+    |       |   |       |--EXPR -> EXPR [59:48]
+    |       |   |       |   `--METHOD_CALL -> ( [59:48]
+    |       |   |       |       |--DOT -> . [59:40]
+    |       |   |       |       |   |--DOT -> . [59:35]
+    |       |   |       |       |   |   |--DOT -> . [59:31]
+    |       |   |       |       |   |   |   |--IDENT -> java [59:27]
+    |       |   |       |       |   |   |   `--IDENT -> sql [59:32]
+    |       |   |       |       |   |   `--IDENT -> Date [59:36]
+    |       |   |       |       |   `--IDENT -> valueOf [59:41]
+    |       |   |       |       |--ELIST -> ELIST [59:49]
+    |       |   |       |       |   `--EXPR -> EXPR [59:49]
+    |       |   |       |       |       `--STRING_LITERAL -> "" [59:49]
+    |       |   |       |       `--RPAREN -> ) [59:51]
+    |       |   |       |--COMMA -> , [59:52]
+    |       |   |       |--EXPR -> EXPR [59:59]
+    |       |   |       |   `--POST_INC -> ++ [59:59]
+    |       |   |       |       `--DOT -> . [59:57]
+    |       |   |       |           |--LITERAL_THIS -> this [59:53]
+    |       |   |       |           `--IDENT -> i [59:58]
+    |       |   |       |--COMMA -> , [59:61]
+    |       |   |       `--EXPR -> EXPR [59:63]
+    |       |   |           `--POST_INC -> ++ [59:63]
+    |       |   |               `--IDENT -> w [59:62]
+    |       |   |--RPAREN -> ) [59:65]
+    |       |   `--SLIST -> { [59:67]
+    |       |       |--EXPR -> EXPR [60:13]
+    |       |       |   `--POST_INC -> ++ [60:13]
+    |       |       |       `--IDENT -> i [60:12]
+    |       |       |--SEMI -> ; [60:15]
+    |       |       |--EXPR -> EXPR [61:13]
+    |       |       |   `--POST_INC -> ++ [61:13]
+    |       |       |       `--IDENT -> w [61:12]
+    |       |       |--SEMI -> ; [61:15]
+    |       |       `--RCURLY -> } [62:8]
+    |       |--LITERAL_FOR -> for [63:8]
+    |       |   |--LPAREN -> ( [63:12]
+    |       |   |--FOR_INIT -> FOR_INIT [63:13]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [63:13]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [63:13]
+    |       |   |   |   |--TYPE -> TYPE [63:13]
+    |       |   |   |   |   `--LITERAL_INT -> int [63:13]
+    |       |   |   |   |--IDENT -> i [63:17]
+    |       |   |   |   `--ASSIGN -> = [63:18]
+    |       |   |   |       `--EXPR -> EXPR [63:19]
+    |       |   |   |           `--NUM_INT -> 0 [63:19]
+    |       |   |   |--COMMA -> , [63:20]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [63:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [63:13]
+    |       |   |       |--TYPE -> TYPE [63:13]
+    |       |   |       |   `--LITERAL_INT -> int [63:13]
+    |       |   |       |--IDENT -> k [63:21]
+    |       |   |       `--ASSIGN -> = [63:22]
+    |       |   |           `--EXPR -> EXPR [63:23]
+    |       |   |               `--NUM_INT -> 0 [63:23]
+    |       |   |--SEMI -> ; [63:24]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [63:31]
+    |       |   |   `--EXPR -> EXPR [63:31]
+    |       |   |       `--LAND -> && [63:31]
+    |       |   |           |--LT -> < [63:27]
+    |       |   |           |   |--IDENT -> i [63:26]
+    |       |   |           |   `--NUM_INT -> 10 [63:28]
+    |       |   |           `--LT -> < [63:36]
+    |       |   |               |--IDENT -> k [63:34]
+    |       |   |               `--NUM_INT -> 10 [63:38]
+    |       |   |--SEMI -> ; [63:40]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [63:42]
+    |       |   |   `--ELIST -> ELIST [63:42]
+    |       |   |       |--EXPR -> EXPR [63:42]
+    |       |   |       |   `--INC -> ++ [63:42]
+    |       |   |       |       `--IDENT -> i [63:44]
+    |       |   |       |--COMMA -> , [63:45]
+    |       |   |       `--EXPR -> EXPR [63:46]
+    |       |   |           `--INC -> ++ [63:46]
+    |       |   |               `--IDENT -> k [63:48]
+    |       |   |--RPAREN -> ) [63:49]
+    |       |   `--SLIST -> { [63:51]
+    |       |       |--EXPR -> EXPR [64:14]
+    |       |       |   `--ASSIGN -> = [64:14]
+    |       |       |       |--IDENT -> i [64:12]
+    |       |       |       `--PLUS -> + [64:18]
+    |       |       |           |--IDENT -> i [64:16]
+    |       |       |           `--NUM_INT -> 3 [64:20]
+    |       |       |--SEMI -> ; [64:21]
+    |       |       |--EXPR -> EXPR [65:14]
+    |       |       |   `--ASSIGN -> = [65:14]
+    |       |       |       |--IDENT -> k [65:12]
+    |       |       |       `--PLUS -> + [65:18]
+    |       |       |           |--IDENT -> k [65:16]
+    |       |       |           `--NUM_INT -> 4 [65:20]
+    |       |       |--SEMI -> ; [65:21]
+    |       |       `--RCURLY -> } [66:8]
+    |       |--LITERAL_FOR -> for [67:8]
+    |       |   |--LPAREN -> ( [67:12]
+    |       |   |--FOR_INIT -> FOR_INIT [67:13]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [67:13]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [67:13]
+    |       |   |   |   |--TYPE -> TYPE [67:13]
+    |       |   |   |   |   `--LITERAL_INT -> int [67:13]
+    |       |   |   |   |--IDENT -> i [67:17]
+    |       |   |   |   `--ASSIGN -> = [67:19]
+    |       |   |   |       `--EXPR -> EXPR [67:21]
+    |       |   |   |           `--NUM_INT -> 0 [67:21]
+    |       |   |   |--COMMA -> , [67:22]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [67:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [67:13]
+    |       |   |       |--TYPE -> TYPE [67:13]
+    |       |   |       |   `--LITERAL_INT -> int [67:13]
+    |       |   |       |--IDENT -> j [67:23]
+    |       |   |       `--ASSIGN -> = [67:25]
+    |       |   |           `--EXPR -> EXPR [67:27]
+    |       |   |               `--NUM_INT -> 0 [67:27]
+    |       |   |--SEMI -> ; [67:29]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [67:33]
+    |       |   |   `--EXPR -> EXPR [67:33]
+    |       |   |       `--LT -> < [67:33]
+    |       |   |           |--IDENT -> i [67:31]
+    |       |   |           `--NUM_INT -> 10 [67:34]
+    |       |   |--SEMI -> ; [67:36]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [67:39]
+    |       |   |   `--ELIST -> ELIST [67:39]
+    |       |   |       `--EXPR -> EXPR [67:39]
+    |       |   |           `--POST_INC -> ++ [67:39]
+    |       |   |               `--IDENT -> i [67:38]
+    |       |   |--RPAREN -> ) [67:41]
+    |       |   `--SLIST -> { [67:43]
+    |       |       |--EXPR -> EXPR [68:13]
+    |       |       |   `--POST_INC -> ++ [68:13]
+    |       |       |       `--IDENT -> j [68:12]
+    |       |       |--SEMI -> ; [68:15]
+    |       |       `--RCURLY -> } [69:8]
+    |       |--LITERAL_FOR -> for [71:8]
+    |       |   |--LPAREN -> ( [71:12]
+    |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [71:13]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [71:13]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [71:13]
+    |       |   |   |   |--TYPE -> TYPE [71:13]
+    |       |   |   |   |   `--IDENT -> String [71:13]
+    |       |   |   |   `--IDENT -> v [71:20]
+    |       |   |   |--COLON -> : [71:22]
+    |       |   |   `--EXPR -> EXPR [71:24]
+    |       |   |       `--IDENT -> sa [71:24]
+    |       |   |--RPAREN -> ) [71:26]
+    |       |   `--SLIST -> { [71:28]
+    |       |       |--EXPR -> EXPR [72:12]
+    |       |       |   `--LITERAL_NEW -> new [72:12]
+    |       |       |       |--IDENT -> NestedClass [72:16]
+    |       |       |       |--LPAREN -> ( [72:27]
+    |       |       |       |--ELIST -> ELIST [72:28]
+    |       |       |       |--RPAREN -> ) [72:28]
+    |       |       |       `--OBJBLOCK -> OBJBLOCK [72:30]
+    |       |       |           |--LCURLY -> { [72:30]
+    |       |       |           |--METHOD_DEF -> METHOD_DEF [73:16]
+    |       |       |           |   |--MODIFIERS -> MODIFIERS [73:16]
+    |       |       |           |   |   `--LITERAL_PUBLIC -> public [73:16]
+    |       |       |           |   |--TYPE -> TYPE [73:23]
+    |       |       |           |   |   `--LITERAL_VOID -> void [73:23]
+    |       |       |           |   |--IDENT -> method [73:28]
+    |       |       |           |   |--LPAREN -> ( [73:34]
+    |       |       |           |   |--PARAMETERS -> PARAMETERS [73:35]
+    |       |       |           |   |--RPAREN -> ) [73:35]
+    |       |       |           |   `--SLIST -> { [73:37]
+    |       |       |           |       `--RCURLY -> } [73:38]
+    |       |       |           `--RCURLY -> } [74:12]
+    |       |       |--SEMI -> ; [74:13]
+    |       |       |--EXPR -> EXPR [75:14]
+    |       |       |   `--ASSIGN -> = [75:14]
+    |       |       |       |--IDENT -> v [75:12]
+    |       |       |       `--STRING_LITERAL -> "bad" [75:16]
+    |       |       |--SEMI -> ; [75:21]
+    |       |       `--RCURLY -> } [76:8]
+    |       |--LITERAL_FOR -> for [77:8]
+    |       |   |--LPAREN -> ( [77:12]
+    |       |   |--FOR_INIT -> FOR_INIT [77:13]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [77:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [77:13]
+    |       |   |       |--TYPE -> TYPE [77:13]
+    |       |   |       |   `--LITERAL_INT -> int [77:13]
+    |       |   |       |--IDENT -> i [77:17]
+    |       |   |       `--ASSIGN -> = [77:19]
+    |       |   |           `--EXPR -> EXPR [77:21]
+    |       |   |               `--NUM_INT -> 0 [77:21]
+    |       |   |--SEMI -> ; [77:22]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [77:26]
+    |       |   |   `--EXPR -> EXPR [77:26]
+    |       |   |       `--LT -> < [77:26]
+    |       |   |           |--IDENT -> i [77:24]
+    |       |   |           `--NUM_INT -> 10 [77:28]
+    |       |   |--SEMI -> ; [77:30]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [77:34]
+    |       |   |   `--ELIST -> ELIST [77:34]
+    |       |   |       `--EXPR -> EXPR [77:34]
+    |       |   |           `--PLUS_ASSIGN -> += [77:34]
+    |       |   |               |--IDENT -> i [77:32]
+    |       |   |               `--NUM_INT -> 1 [77:37]
+    |       |   |--RPAREN -> ) [77:38]
+    |       |   `--SLIST -> { [77:40]
+    |       |       |--LITERAL_FOR -> for [78:12]
+    |       |       |   |--LPAREN -> ( [78:16]
+    |       |       |   |--FOR_INIT -> FOR_INIT [78:19]
+    |       |       |   |   `--ELIST -> ELIST [78:19]
+    |       |       |   |       `--EXPR -> EXPR [78:19]
+    |       |       |   |           `--ASSIGN -> = [78:19]
+    |       |       |   |               |--IDENT -> i [78:17]
+    |       |       |   |               `--NUM_INT -> 7 [78:21]
+    |       |       |   |--SEMI -> ; [78:22]
+    |       |       |   |--FOR_CONDITION -> FOR_CONDITION [78:26]
+    |       |       |   |   `--EXPR -> EXPR [78:26]
+    |       |       |   |       `--LT -> < [78:26]
+    |       |       |   |           |--IDENT -> i [78:24]
+    |       |       |   |           `--NUM_INT -> 10 [78:28]
+    |       |       |   |--SEMI -> ; [78:30]
+    |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [78:34]
+    |       |       |   |   `--ELIST -> ELIST [78:34]
+    |       |       |   |       `--EXPR -> EXPR [78:34]
+    |       |       |   |           `--PLUS_ASSIGN -> += [78:34]
+    |       |       |   |               |--IDENT -> i [78:32]
+    |       |       |   |               `--NUM_INT -> 1 [78:37]
+    |       |       |   |--RPAREN -> ) [78:38]
+    |       |       |   `--SLIST -> { [78:40]
+    |       |       |       `--RCURLY -> } [78:41]
+    |       |       `--RCURLY -> } [79:8]
+    |       |--LITERAL_FOR -> for [80:8]
+    |       |   |--LPAREN -> ( [80:12]
+    |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [80:13]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [80:13]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [80:13]
+    |       |   |   |   |--TYPE -> TYPE [80:13]
+    |       |   |   |   |   `--IDENT -> String [80:13]
+    |       |   |   |   `--IDENT -> name [80:20]
+    |       |   |   |--COLON -> : [80:24]
+    |       |   |   `--EXPR -> EXPR [80:26]
+    |       |   |       `--LITERAL_NEW -> new [80:26]
+    |       |   |           |--IDENT -> String [80:30]
+    |       |   |           |--ARRAY_DECLARATOR -> [ [80:36]
+    |       |   |           |   `--RBRACK -> ] [80:37]
+    |       |   |           `--ARRAY_INIT -> { [80:39]
+    |       |   |               `--RCURLY -> } [80:40]
+    |       |   |--RPAREN -> ) [80:41]
+    |       |   `--SLIST -> { [80:43]
+    |       |       `--RCURLY -> } [81:8]
+    |       |--LITERAL_FOR -> for [83:8]
+    |       |   |--LPAREN -> ( [83:12]
+    |       |   |--FOR_INIT -> FOR_INIT [83:15]
+    |       |   |   `--ELIST -> ELIST [83:15]
+    |       |   |       `--EXPR -> EXPR [83:15]
+    |       |   |           `--ASSIGN -> = [83:15]
+    |       |   |               |--IDENT -> i [83:13]
+    |       |   |               `--NUM_INT -> 0 [83:17]
+    |       |   |--SEMI -> ; [83:18]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [83:22]
+    |       |   |   `--EXPR -> EXPR [83:22]
+    |       |   |       `--LT -> < [83:22]
+    |       |   |           |--IDENT -> i [83:20]
+    |       |   |           `--NUM_INT -> 10 [83:24]
+    |       |   |--SEMI -> ; [83:26]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [83:29]
+    |       |   |   `--ELIST -> ELIST [83:29]
+    |       |   |       `--EXPR -> EXPR [83:29]
+    |       |   |           `--POST_INC -> ++ [83:29]
+    |       |   |               `--IDENT -> i [83:28]
+    |       |   |--RPAREN -> ) [83:31]
+    |       |   `--SLIST -> { [83:33]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [84:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [84:12]
+    |       |       |   |--TYPE -> TYPE [84:12]
+    |       |       |   |   `--IDENT -> String [84:12]
+    |       |       |   `--IDENT -> name [84:19]
+    |       |       |--SEMI -> ; [84:23]
+    |       |       |--EXPR -> EXPR [85:17]
+    |       |       |   `--ASSIGN -> = [85:17]
+    |       |       |       |--IDENT -> name [85:12]
+    |       |       |       `--STRING_LITERAL -> "" [85:19]
+    |       |       |--SEMI -> ; [85:21]
+    |       |       `--RCURLY -> } [86:8]
+    |       |--LITERAL_FOR -> for [87:8]
+    |       |   |--LPAREN -> ( [87:12]
+    |       |   |--FOR_INIT -> FOR_INIT [87:13]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [87:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [87:13]
+    |       |   |       |--TYPE -> TYPE [87:13]
+    |       |   |       |   `--LITERAL_INT -> int [87:13]
+    |       |   |       |--IDENT -> EXPR [87:17]
+    |       |   |       `--ASSIGN -> = [87:22]
+    |       |   |           `--EXPR -> EXPR [87:24]
+    |       |   |               `--NUM_INT -> 0 [87:24]
+    |       |   |--SEMI -> ; [87:25]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [87:32]
+    |       |   |   `--EXPR -> EXPR [87:32]
+    |       |   |       `--LT -> < [87:32]
+    |       |   |           |--IDENT -> EXPR [87:27]
+    |       |   |           `--NUM_INT -> 1 [87:34]
+    |       |   |--SEMI -> ; [87:35]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [87:41]
+    |       |   |   `--ELIST -> ELIST [87:41]
+    |       |   |       `--EXPR -> EXPR [87:41]
+    |       |   |           `--POST_INC -> ++ [87:41]
+    |       |   |               `--IDENT -> EXPR [87:37]
+    |       |   |--RPAREN -> ) [87:43]
+    |       |   `--SLIST -> { [87:45]
+    |       |       |--LITERAL_FOR -> for [88:12]
+    |       |       |   |--LPAREN -> ( [88:16]
+    |       |       |   |--FOR_INIT -> FOR_INIT [88:17]
+    |       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [88:17]
+    |       |       |   |       |--MODIFIERS -> MODIFIERS [88:17]
+    |       |       |   |       |--TYPE -> TYPE [88:17]
+    |       |       |   |       |   `--LITERAL_INT -> int [88:17]
+    |       |       |   |       |--IDENT -> j [88:21]
+    |       |       |   |       `--ASSIGN -> = [88:23]
+    |       |       |   |           `--EXPR -> EXPR [88:25]
+    |       |       |   |               `--NUM_INT -> 0 [88:25]
+    |       |       |   |--SEMI -> ; [88:26]
+    |       |       |   |--FOR_CONDITION -> FOR_CONDITION [88:30]
+    |       |       |   |   `--EXPR -> EXPR [88:30]
+    |       |       |   |       `--LT -> < [88:30]
+    |       |       |   |           |--IDENT -> j [88:28]
+    |       |       |   |           `--NUM_INT -> 1 [88:32]
+    |       |       |   |--SEMI -> ; [88:33]
+    |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [88:36]
+    |       |       |   |   `--ELIST -> ELIST [88:36]
+    |       |       |   |       `--EXPR -> EXPR [88:36]
+    |       |       |   |           `--POST_INC -> ++ [88:36]
+    |       |       |   |               `--IDENT -> i [88:35]
+    |       |       |   |--RPAREN -> ) [88:38]
+    |       |       |   `--SLIST -> { [88:40]
+    |       |       |       |--EXPR -> EXPR [89:17]
+    |       |       |       |   `--POST_INC -> ++ [89:17]
+    |       |       |       |       `--IDENT -> i [89:16]
+    |       |       |       |--SEMI -> ; [89:19]
+    |       |       |       `--RCURLY -> } [90:12]
+    |       |       `--RCURLY -> } [91:8]
+    |       `--RCURLY -> } [92:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [93:4]
+    |   |--MODIFIERS -> MODIFIERS [93:4]
+    |   |   `--LITERAL_PRIVATE -> private [93:4]
+    |   |--TYPE -> TYPE [93:12]
+    |   |   `--LITERAL_INT -> int [93:12]
+    |   |--IDENT -> i [93:16]
+    |   `--SEMI -> ; [93:17]
+    `--RCURLY -> } [94:0]
+CLASS_DEF -> CLASS_DEF [96:0]
+|--MODIFIERS -> MODIFIERS [96:0]
+|   `--ANNOTATION -> ANNOTATION [96:0]
+|       |--AT -> @ [96:0]
+|       |--IDENT -> SuppressWarnings [96:1]
+|       |--LPAREN -> ( [96:17]
+|       |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [96:18]
+|       |   |--IDENT -> value [96:18]
+|       |   |--ASSIGN -> = [96:24]
+|       |   `--EXPR -> EXPR [96:26]
+|       |       `--STRING_LITERAL -> "this previously caused NullPointerException" [96:26]
+|       `--RPAREN -> ) [96:71]
+|--LITERAL_CLASS -> class [97:0]
+|--IDENT -> VariableDeclaredBeforeTheFirstBlockBegins [97:6]
+`--OBJBLOCK -> OBJBLOCK [97:48]
+    |--LCURLY -> { [97:48]
+    |--METHOD_DEF -> METHOD_DEF [98:4]
+    |   |--MODIFIERS -> MODIFIERS [98:4]
+    |   |--TYPE -> TYPE [98:4]
+    |   |   `--LITERAL_VOID -> void [98:4]
+    |   |--IDENT -> foo [98:9]
+    |   |--LPAREN -> ( [98:12]
+    |   |--PARAMETERS -> PARAMETERS [98:13]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [98:13]
+    |   |       |--MODIFIERS -> MODIFIERS [98:13]
+    |   |       |--TYPE -> TYPE [98:13]
+    |   |       |   |--IDENT -> String [98:13]
+    |   |       |   `--ARRAY_DECLARATOR -> [ [98:19]
+    |   |       |       `--RBRACK -> ] [98:20]
+    |   |       `--IDENT -> requests [98:22]
+    |   |--RPAREN -> ) [98:30]
+    |   `--SLIST -> { [98:32]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [99:8]
+    |       |   |--MODIFIERS -> MODIFIERS [99:8]
+    |       |   |--TYPE -> TYPE [99:8]
+    |       |   |   `--IDENT -> Class [99:8]
+    |       |   |--IDENT -> mUse4 [99:14]
+    |       |   `--ASSIGN -> = [99:20]
+    |       |       `--EXPR -> EXPR [99:45]
+    |       |           `--DOT -> . [99:45]
+    |       |               |--DOT -> . [99:31]
+    |       |               |   |--DOT -> . [99:26]
+    |       |               |   |   |--IDENT -> java [99:22]
+    |       |               |   |   `--IDENT -> util [99:27]
+    |       |               |   |--IDENT -> Enumeration [99:32]
+    |       |               |   `--ARRAY_DECLARATOR -> [ [99:43]
+    |       |               |       `--RBRACK -> ] [99:44]
+    |       |               `--LITERAL_CLASS -> class [99:46]
+    |       |--SEMI -> ; [99:51]
+    |       |--LITERAL_FOR -> for [100:8]
+    |       |   |--LPAREN -> ( [100:12]
+    |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [100:13]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [100:13]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [100:13]
+    |       |   |   |   |--TYPE -> TYPE [100:13]
+    |       |   |   |   |   `--IDENT -> String [100:13]
+    |       |   |   |   `--IDENT -> eventDataType [100:20]
+    |       |   |   |--COLON -> : [100:34]
+    |       |   |   `--EXPR -> EXPR [100:36]
+    |       |   |       `--IDENT -> requests [100:36]
+    |       |   |--RPAREN -> ) [100:44]
+    |       |   `--SLIST -> { [100:46]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [101:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [101:12]
+    |       |       |   |   `--ANNOTATION -> ANNOTATION [101:12]
+    |       |       |   |       |--AT -> @ [101:12]
+    |       |       |   |       |--IDENT -> SuppressWarnings [101:13]
+    |       |       |   |       |--LPAREN -> ( [101:29]
+    |       |       |   |       |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [101:30]
+    |       |       |   |       |   |--IDENT -> value [101:30]
+    |       |       |   |       |   |--ASSIGN -> = [101:36]
+    |       |       |   |       |   `--EXPR -> EXPR [101:38]
+    |       |       |   |       |       `--STRING_LITERAL -> "this previously caused NullPointerException" [101:38]
+    |       |       |   |       `--RPAREN -> ) [101:83]
+    |       |       |   |--TYPE -> TYPE [102:12]
+    |       |       |   |   `--IDENT -> String [102:12]
+    |       |       |   `--IDENT -> eventData [102:19]
+    |       |       |--SEMI -> ; [102:28]
+    |       |       `--RCURLY -> } [103:8]
+    |       `--RCURLY -> } [104:4]
+    `--RCURLY -> } [105:0]
+CLASS_DEF -> CLASS_DEF [106:0]
+|--MODIFIERS -> MODIFIERS [106:0]
+|   `--ABSTRACT -> abstract [106:0]
+|--LITERAL_CLASS -> class [106:9]
+|--IDENT -> NestedClass [106:15]
+`--OBJBLOCK -> OBJBLOCK [106:27]
+    |--LCURLY -> { [106:27]
+    |--METHOD_DEF -> METHOD_DEF [107:4]
+    |   |--MODIFIERS -> MODIFIERS [107:4]
+    |   |   |--LITERAL_PUBLIC -> public [107:4]
+    |   |   `--ABSTRACT -> abstract [107:11]
+    |   |--TYPE -> TYPE [107:20]
+    |   |   `--LITERAL_VOID -> void [107:20]
+    |   |--IDENT -> method [107:25]
+    |   |--LPAREN -> ( [107:31]
+    |   |--PARAMETERS -> PARAMETERS [107:32]
+    |   |--RPAREN -> ) [107:32]
+    |   `--SEMI -> ; [107:33]
+    `--RCURLY -> } [108:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionIllegalCatch.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionIllegalCatch.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionIllegalCatch.java
@@ -0,0 +1,19 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+public class InputAntlr4AstRegressionIllegalCatch {
+    public void foo() {
+        try { //class names
+        } catch (RuntimeException e) {
+        } catch (Exception e) {
+        } catch (Throwable e) {
+        }
+    }
+
+    public void bar() {
+        try { /* fully qualified class names */
+        } catch (java.lang.RuntimeException e) {
+        } catch (java.lang.Exception e) {
+        } catch (java.lang.Throwable e) {
+        }
+    }
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionIllegalCatch.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionIllegalCatch.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionIllegalCatch.txt
@@ -0,0 +1,122 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+CLASS_DEF -> CLASS_DEF [3:0]
+|--MODIFIERS -> MODIFIERS [3:0]
+|   `--LITERAL_PUBLIC -> public [3:0]
+|--LITERAL_CLASS -> class [3:7]
+|--IDENT -> InputAntlr4AstRegressionIllegalCatch [3:13]
+`--OBJBLOCK -> OBJBLOCK [3:50]
+    |--LCURLY -> { [3:50]
+    |--METHOD_DEF -> METHOD_DEF [4:4]
+    |   |--MODIFIERS -> MODIFIERS [4:4]
+    |   |   `--LITERAL_PUBLIC -> public [4:4]
+    |   |--TYPE -> TYPE [4:11]
+    |   |   `--LITERAL_VOID -> void [4:11]
+    |   |--IDENT -> foo [4:16]
+    |   |--LPAREN -> ( [4:19]
+    |   |--PARAMETERS -> PARAMETERS [4:20]
+    |   |--RPAREN -> ) [4:20]
+    |   `--SLIST -> { [4:22]
+    |       |--LITERAL_TRY -> try [5:8]
+    |       |   |--SLIST -> { [5:12]
+    |       |   |   `--RCURLY -> } [6:8]
+    |       |   |--LITERAL_CATCH -> catch [6:10]
+    |       |   |   |--LPAREN -> ( [6:16]
+    |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [6:17]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [6:17]
+    |       |   |   |   |--TYPE -> TYPE [6:17]
+    |       |   |   |   |   `--IDENT -> RuntimeException [6:17]
+    |       |   |   |   `--IDENT -> e [6:34]
+    |       |   |   |--RPAREN -> ) [6:35]
+    |       |   |   `--SLIST -> { [6:37]
+    |       |   |       `--RCURLY -> } [7:8]
+    |       |   |--LITERAL_CATCH -> catch [7:10]
+    |       |   |   |--LPAREN -> ( [7:16]
+    |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [7:17]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [7:17]
+    |       |   |   |   |--TYPE -> TYPE [7:17]
+    |       |   |   |   |   `--IDENT -> Exception [7:17]
+    |       |   |   |   `--IDENT -> e [7:27]
+    |       |   |   |--RPAREN -> ) [7:28]
+    |       |   |   `--SLIST -> { [7:30]
+    |       |   |       `--RCURLY -> } [8:8]
+    |       |   `--LITERAL_CATCH -> catch [8:10]
+    |       |       |--LPAREN -> ( [8:16]
+    |       |       |--PARAMETER_DEF -> PARAMETER_DEF [8:17]
+    |       |       |   |--MODIFIERS -> MODIFIERS [8:17]
+    |       |       |   |--TYPE -> TYPE [8:17]
+    |       |       |   |   `--IDENT -> Throwable [8:17]
+    |       |       |   `--IDENT -> e [8:27]
+    |       |       |--RPAREN -> ) [8:28]
+    |       |       `--SLIST -> { [8:30]
+    |       |           `--RCURLY -> } [9:8]
+    |       `--RCURLY -> } [10:4]
+    |--METHOD_DEF -> METHOD_DEF [12:4]
+    |   |--MODIFIERS -> MODIFIERS [12:4]
+    |   |   `--LITERAL_PUBLIC -> public [12:4]
+    |   |--TYPE -> TYPE [12:11]
+    |   |   `--LITERAL_VOID -> void [12:11]
+    |   |--IDENT -> bar [12:16]
+    |   |--LPAREN -> ( [12:19]
+    |   |--PARAMETERS -> PARAMETERS [12:20]
+    |   |--RPAREN -> ) [12:20]
+    |   `--SLIST -> { [12:22]
+    |       |--LITERAL_TRY -> try [13:8]
+    |       |   |--SLIST -> { [13:12]
+    |       |   |   `--RCURLY -> } [14:8]
+    |       |   |--LITERAL_CATCH -> catch [14:10]
+    |       |   |   |--LPAREN -> ( [14:16]
+    |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [14:26]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [14:26]
+    |       |   |   |   |--TYPE -> TYPE [14:26]
+    |       |   |   |   |   `--DOT -> . [14:26]
+    |       |   |   |   |       |--DOT -> . [14:21]
+    |       |   |   |   |       |   |--IDENT -> java [14:17]
+    |       |   |   |   |       |   `--IDENT -> lang [14:22]
+    |       |   |   |   |       `--IDENT -> RuntimeException [14:27]
+    |       |   |   |   `--IDENT -> e [14:44]
+    |       |   |   |--RPAREN -> ) [14:45]
+    |       |   |   `--SLIST -> { [14:47]
+    |       |   |       `--RCURLY -> } [15:8]
+    |       |   |--LITERAL_CATCH -> catch [15:10]
+    |       |   |   |--LPAREN -> ( [15:16]
+    |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [15:26]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [15:26]
+    |       |   |   |   |--TYPE -> TYPE [15:26]
+    |       |   |   |   |   `--DOT -> . [15:26]
+    |       |   |   |   |       |--DOT -> . [15:21]
+    |       |   |   |   |       |   |--IDENT -> java [15:17]
+    |       |   |   |   |       |   `--IDENT -> lang [15:22]
+    |       |   |   |   |       `--IDENT -> Exception [15:27]
+    |       |   |   |   `--IDENT -> e [15:37]
+    |       |   |   |--RPAREN -> ) [15:38]
+    |       |   |   `--SLIST -> { [15:40]
+    |       |   |       `--RCURLY -> } [16:8]
+    |       |   `--LITERAL_CATCH -> catch [16:10]
+    |       |       |--LPAREN -> ( [16:16]
+    |       |       |--PARAMETER_DEF -> PARAMETER_DEF [16:26]
+    |       |       |   |--MODIFIERS -> MODIFIERS [16:26]
+    |       |       |   |--TYPE -> TYPE [16:26]
+    |       |       |   |   `--DOT -> . [16:26]
+    |       |       |   |       |--DOT -> . [16:21]
+    |       |       |   |       |   |--IDENT -> java [16:17]
+    |       |       |   |       |   `--IDENT -> lang [16:22]
+    |       |       |   |       `--IDENT -> Throwable [16:27]
+    |       |       |   `--IDENT -> e [16:37]
+    |       |       |--RPAREN -> ) [16:38]
+    |       |       `--SLIST -> { [16:40]
+    |       |           `--RCURLY -> } [17:8]
+    |       `--RCURLY -> } [18:4]
+    `--RCURLY -> } [19:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionImports.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionImports.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionImports.java
@@ -0,0 +1,18 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import static java.lang.String.valueOf;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import javax.xml.*;
+
+public class InputAntlr4AstRegressionImports {
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionImports.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionImports.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionImports.txt
@@ -0,0 +1,102 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+STATIC_IMPORT -> import [3:0]
+|--LITERAL_STATIC -> static [3:7]
+|--DOT -> . [3:30]
+|   |--DOT -> . [3:23]
+|   |   |--DOT -> . [3:18]
+|   |   |   |--IDENT -> java [3:14]
+|   |   |   `--IDENT -> lang [3:19]
+|   |   `--IDENT -> String [3:24]
+|   `--IDENT -> valueOf [3:31]
+`--SEMI -> ; [3:38]
+IMPORT -> import [5:0]
+|--DOT -> . [5:14]
+|   |--DOT -> . [5:11]
+|   |   |--IDENT -> java [5:7]
+|   |   `--IDENT -> io [5:12]
+|   `--IDENT -> BufferedReader [5:15]
+`--SEMI -> ; [5:29]
+IMPORT -> import [6:0]
+|--DOT -> . [6:14]
+|   |--DOT -> . [6:11]
+|   |   |--IDENT -> java [6:7]
+|   |   `--IDENT -> io [6:12]
+|   `--IDENT -> FileNotFoundException [6:15]
+`--SEMI -> ; [6:36]
+IMPORT -> import [7:0]
+|--DOT -> . [7:14]
+|   |--DOT -> . [7:11]
+|   |   |--IDENT -> java [7:7]
+|   |   `--IDENT -> io [7:12]
+|   `--IDENT -> IOException [7:15]
+`--SEMI -> ; [7:26]
+IMPORT -> import [8:0]
+|--DOT -> . [8:14]
+|   |--DOT -> . [8:11]
+|   |   |--IDENT -> java [8:7]
+|   |   `--IDENT -> io [8:12]
+|   `--IDENT -> InputStreamReader [8:15]
+`--SEMI -> ; [8:32]
+IMPORT -> import [9:0]
+|--DOT -> . [9:16]
+|   |--DOT -> . [9:11]
+|   |   |--IDENT -> java [9:7]
+|   |   `--IDENT -> util [9:12]
+|   `--IDENT -> ArrayList [9:17]
+`--SEMI -> ; [9:26]
+IMPORT -> import [10:0]
+|--DOT -> . [10:16]
+|   |--DOT -> . [10:11]
+|   |   |--IDENT -> java [10:7]
+|   |   `--IDENT -> util [10:12]
+|   `--IDENT -> HashMap [10:17]
+`--SEMI -> ; [10:24]
+IMPORT -> import [11:0]
+|--DOT -> . [11:16]
+|   |--DOT -> . [11:11]
+|   |   |--IDENT -> java [11:7]
+|   |   `--IDENT -> util [11:12]
+|   `--IDENT -> Iterator [11:17]
+`--SEMI -> ; [11:25]
+IMPORT -> import [12:0]
+|--DOT -> . [12:16]
+|   |--DOT -> . [12:11]
+|   |   |--IDENT -> java [12:7]
+|   |   `--IDENT -> util [12:12]
+|   `--IDENT -> List [12:17]
+`--SEMI -> ; [12:21]
+IMPORT -> import [13:0]
+|--DOT -> . [13:16]
+|   |--DOT -> . [13:11]
+|   |   |--IDENT -> java [13:7]
+|   |   `--IDENT -> util [13:12]
+|   `--IDENT -> Map [13:17]
+`--SEMI -> ; [13:20]
+IMPORT -> import [15:0]
+|--DOT -> . [15:16]
+|   |--DOT -> . [15:12]
+|   |   |--IDENT -> javax [15:7]
+|   |   `--IDENT -> xml [15:13]
+|   `--STAR -> * [15:17]
+`--SEMI -> ; [15:18]
+CLASS_DEF -> CLASS_DEF [17:0]
+|--MODIFIERS -> MODIFIERS [17:0]
+|   `--LITERAL_PUBLIC -> public [17:0]
+|--LITERAL_CLASS -> class [17:7]
+|--IDENT -> InputAntlr4AstRegressionImports [17:13]
+`--OBJBLOCK -> OBJBLOCK [17:45]
+    |--LCURLY -> { [17:45]
+    `--RCURLY -> } [18:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionKeywordsAndOperators.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionKeywordsAndOperators.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionKeywordsAndOperators.java
@@ -0,0 +1,282 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+public class InputAntlr4AstRegressionKeywordsAndOperators {
+        /** ignore assignment **/
+    private int mVar1=1;
+    /** ignore assignment **/
+    private int mVar2 =1;
+    /** Should be ok **/
+    private int mVar3 = 1;
+
+    /** method **/
+    void method1()
+    {
+        final int a = 1;
+        int b= 1; // Ignore 1
+        b=1; // Ignore 1
+        b+=1; // Ignore 1
+        b -=- 1 + (+ b); // Ignore 2
+        b = b ++ + b --; // Ignore 1
+        b = ++ b - -- b; // Ignore 1
+    }
+
+    /** method **/
+    void method2()
+    {
+        synchronized(this) {
+        }
+        try{
+        }
+        catch(RuntimeException e){
+        }
+    }
+
+    /**
+       skip blank lines between comment and code,
+       should be ok
+    **/
+
+
+    private int mVar4 = 1;
+
+
+    /** test WS after void return */
+    private void fastExit()
+    {
+        boolean complicatedStuffNeeded = true;
+        if( !complicatedStuffNeeded )
+        {
+            return; // should not complain about missing WS after return
+        }
+        else
+        {
+            // do complicated stuff
+        }
+    }
+
+
+    /** test WS after non void return
+     @return 2
+    */
+    private int nonVoid()
+    {
+        if ( true )
+        {
+            return(2); // should complain about missing WS after return
+        }
+        else
+        {
+            return 2; // this is ok
+        }
+    }
+
+    /** test casts **/
+    private void testCasts()
+    {
+        Object o = (Object) new Object(); // ok
+        o = (Object)o; // violation
+        o = ( Object ) o; // ok
+        o = (Object)
+            o; // ok
+    }
+
+    /** test questions **/
+    private void testQuestions()
+    {
+        boolean b = (1 == 2)?true:false;
+        b = (1==2) ? false : true;
+    }
+
+    /** star test **/
+    private void starTest()
+    {
+        int x = 2 *3* 4;
+    }
+
+    /** boolean test **/
+    private void boolTest()
+    {
+        boolean a = true;
+        boolean x = ! a;
+        int z = ~1 + ~ 2;
+    }
+
+    /** division test **/
+    private void divTest()
+    {
+        int a = 4 % 2;
+        int b = 4% 2;
+        int c = 4 %2;
+        int d = 4%2;
+        int e = 4 / 2;
+        int f = 4/ 2;
+        int g = 4 /2;
+        int h = 4/2;
+    }
+
+    /** @return dot test **/
+    private java .lang.  String dotTest()
+    {
+        Object o = new java.lang.Object();
+        o.
+            toString();
+        o
+            .toString();
+        o . toString();
+        return o.toString();
+    }
+
+    /** assert statement test */
+    public void assertTest()
+    {
+        // OK
+        assert true;
+
+        // OK
+        assert true : "Whups";
+
+        // evil colons, should be OK
+        assert "OK".equals(null) ? false : true : "Whups";
+
+        // missing WS around assert
+        assert(true);
+
+        // missing WS around colon
+        assert true:"Whups";
+    }
+
+    /** another check */
+    void donBradman(Runnable aRun)
+    {
+        donBradman(new Runnable() {
+            public void run() {
+            }
+        });
+
+        final Runnable r = new Runnable() {
+            public void run() {
+            }
+        };
+    }
+
+    /** rfe 521323, detect whitespace before ';' */
+    void rfe521323()
+    {
+        doStuff() ;
+        //       ^ whitespace
+        for (int i = 0 ; i < 5; i++) {
+            //        ^ whitespace
+        }
+    }
+
+
+    /** bug 806243 (NoWhitespaceBeforeCheck violation for anonymous inner class) */
+    private int i ;
+    //           ^ whitespace
+    private int i1, i2, i3 ;
+    //                    ^ whitespace
+    private int i4, i5, i6;
+
+    /** bug 806243 (NoWhitespaceBeforeCheck violation for anonymous inner class) */
+    void bug806243()
+    {
+        Object o = new InputAntlr4AstRegressionKeywordsAndOperators() {
+            private int j ;
+            //           ^ whitespace
+        };
+    }
+
+    void doStuff() {
+    }
+}
+
+/**
+ * Bug 806242 (NoWhitespaceBeforeCheck violation with an interface).
+ * @author o_sukhodolsky
+ * @version 1.0
+ */
+interface IFoo
+{
+    void foo() ;
+    //        ^ whitespace
+}
+
+/**
+ * Avoid Whitespace violations in for loop.
+ * @author lkuehne
+ * @version 1.0
+ */
+class SpecialCasesInForLoop
+{
+    void forIterator()
+    {
+        // avoid conflict between WhiteSpaceAfter ';' and ParenPad(nospace)
+        for (int i = 0; i++ < 5;) {
+        //                  ^ no whitespace
+    }
+
+        // bug 895072
+    // avoid conflict between ParenPad(space) and NoWhiteSpace before ';'
+    int i = 0;
+    for ( ; i < 5; i++ ) {
+    //   ^ whitespace
+    }
+        for (int anInt : getSomeInts()) {
+            //Should be ignored
+        }
+    }
+
+    int[] getSomeInts() {
+        int i = (int) ( 2 / 3 );
+        return null;
+    }
+
+    public void myMethod() {
+        new Thread() {
+            public void run() {
+            }
+        }.start();
+    }
+
+    public void foo(java.util.List<? extends String[]> bar, Comparable<? super Object[]> baz) { }
+
+    public void mySuperMethod() {
+        Runnable[] runs = new Runnable[] {new Runnable() {
+                public void run() {
+                }
+            },
+            new Runnable() {
+                public void run() {
+                }
+            }};
+        runs[0]
+.
+ run()
+;
+    }
+
+    public void testNullSemi() {
+        return ;
+    }
+
+    public void register(Object obj) { }
+
+    public void doSomething(String args[]) {
+        register(boolean[].class);
+        register( args );
+    }
+
+    public void parentheses() {
+        testNullSemi
+(
+)
+;
+    }
+
+    public static void testNoWhitespaceBeforeEllipses(String ... args) {
+    }
+    public String test() {
+        int pc = 0;
+        return ((100000+pc)+"").substring(1);
+    }
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionKeywordsAndOperators.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionKeywordsAndOperators.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionKeywordsAndOperators.txt
@@ -0,0 +1,1242 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+CLASS_DEF -> CLASS_DEF [3:0]
+|--MODIFIERS -> MODIFIERS [3:0]
+|   `--LITERAL_PUBLIC -> public [3:0]
+|--LITERAL_CLASS -> class [3:7]
+|--IDENT -> InputAntlr4AstRegressionKeywordsAndOperators [3:13]
+`--OBJBLOCK -> OBJBLOCK [3:58]
+    |--LCURLY -> { [3:58]
+    |--VARIABLE_DEF -> VARIABLE_DEF [5:4]
+    |   |--MODIFIERS -> MODIFIERS [5:4]
+    |   |   `--LITERAL_PRIVATE -> private [5:4]
+    |   |--TYPE -> TYPE [5:12]
+    |   |   `--LITERAL_INT -> int [5:12]
+    |   |--IDENT -> mVar1 [5:16]
+    |   |--ASSIGN -> = [5:21]
+    |   |   `--EXPR -> EXPR [5:22]
+    |   |       `--NUM_INT -> 1 [5:22]
+    |   `--SEMI -> ; [5:23]
+    |--VARIABLE_DEF -> VARIABLE_DEF [7:4]
+    |   |--MODIFIERS -> MODIFIERS [7:4]
+    |   |   `--LITERAL_PRIVATE -> private [7:4]
+    |   |--TYPE -> TYPE [7:12]
+    |   |   `--LITERAL_INT -> int [7:12]
+    |   |--IDENT -> mVar2 [7:16]
+    |   |--ASSIGN -> = [7:22]
+    |   |   `--EXPR -> EXPR [7:23]
+    |   |       `--NUM_INT -> 1 [7:23]
+    |   `--SEMI -> ; [7:24]
+    |--VARIABLE_DEF -> VARIABLE_DEF [9:4]
+    |   |--MODIFIERS -> MODIFIERS [9:4]
+    |   |   `--LITERAL_PRIVATE -> private [9:4]
+    |   |--TYPE -> TYPE [9:12]
+    |   |   `--LITERAL_INT -> int [9:12]
+    |   |--IDENT -> mVar3 [9:16]
+    |   |--ASSIGN -> = [9:22]
+    |   |   `--EXPR -> EXPR [9:24]
+    |   |       `--NUM_INT -> 1 [9:24]
+    |   `--SEMI -> ; [9:25]
+    |--METHOD_DEF -> METHOD_DEF [12:4]
+    |   |--MODIFIERS -> MODIFIERS [12:4]
+    |   |--TYPE -> TYPE [12:4]
+    |   |   `--LITERAL_VOID -> void [12:4]
+    |   |--IDENT -> method1 [12:9]
+    |   |--LPAREN -> ( [12:16]
+    |   |--PARAMETERS -> PARAMETERS [12:17]
+    |   |--RPAREN -> ) [12:17]
+    |   `--SLIST -> { [13:4]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [14:8]
+    |       |   |--MODIFIERS -> MODIFIERS [14:8]
+    |       |   |   `--FINAL -> final [14:8]
+    |       |   |--TYPE -> TYPE [14:14]
+    |       |   |   `--LITERAL_INT -> int [14:14]
+    |       |   |--IDENT -> a [14:18]
+    |       |   `--ASSIGN -> = [14:20]
+    |       |       `--EXPR -> EXPR [14:22]
+    |       |           `--NUM_INT -> 1 [14:22]
+    |       |--SEMI -> ; [14:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [15:8]
+    |       |   |--MODIFIERS -> MODIFIERS [15:8]
+    |       |   |--TYPE -> TYPE [15:8]
+    |       |   |   `--LITERAL_INT -> int [15:8]
+    |       |   |--IDENT -> b [15:12]
+    |       |   `--ASSIGN -> = [15:13]
+    |       |       `--EXPR -> EXPR [15:15]
+    |       |           `--NUM_INT -> 1 [15:15]
+    |       |--SEMI -> ; [15:16]
+    |       |--EXPR -> EXPR [16:9]
+    |       |   `--ASSIGN -> = [16:9]
+    |       |       |--IDENT -> b [16:8]
+    |       |       `--NUM_INT -> 1 [16:10]
+    |       |--SEMI -> ; [16:11]
+    |       |--EXPR -> EXPR [17:9]
+    |       |   `--PLUS_ASSIGN -> += [17:9]
+    |       |       |--IDENT -> b [17:8]
+    |       |       `--NUM_INT -> 1 [17:11]
+    |       |--SEMI -> ; [17:12]
+    |       |--EXPR -> EXPR [18:10]
+    |       |   `--MINUS_ASSIGN -> -= [18:10]
+    |       |       |--IDENT -> b [18:8]
+    |       |       `--PLUS -> + [18:16]
+    |       |           |--UNARY_MINUS -> - [18:12]
+    |       |           |   `--NUM_INT -> 1 [18:14]
+    |       |           |--LPAREN -> ( [18:18]
+    |       |           |--UNARY_PLUS -> + [18:19]
+    |       |           |   `--IDENT -> b [18:21]
+    |       |           `--RPAREN -> ) [18:22]
+    |       |--SEMI -> ; [18:23]
+    |       |--EXPR -> EXPR [19:10]
+    |       |   `--ASSIGN -> = [19:10]
+    |       |       |--IDENT -> b [19:8]
+    |       |       `--PLUS -> + [19:17]
+    |       |           |--POST_INC -> ++ [19:14]
+    |       |           |   `--IDENT -> b [19:12]
+    |       |           `--POST_DEC -> -- [19:21]
+    |       |               `--IDENT -> b [19:19]
+    |       |--SEMI -> ; [19:23]
+    |       |--EXPR -> EXPR [20:10]
+    |       |   `--ASSIGN -> = [20:10]
+    |       |       |--IDENT -> b [20:8]
+    |       |       `--MINUS -> - [20:17]
+    |       |           |--INC -> ++ [20:12]
+    |       |           |   `--IDENT -> b [20:15]
+    |       |           `--DEC -> -- [20:19]
+    |       |               `--IDENT -> b [20:22]
+    |       |--SEMI -> ; [20:23]
+    |       `--RCURLY -> } [21:4]
+    |--METHOD_DEF -> METHOD_DEF [24:4]
+    |   |--MODIFIERS -> MODIFIERS [24:4]
+    |   |--TYPE -> TYPE [24:4]
+    |   |   `--LITERAL_VOID -> void [24:4]
+    |   |--IDENT -> method2 [24:9]
+    |   |--LPAREN -> ( [24:16]
+    |   |--PARAMETERS -> PARAMETERS [24:17]
+    |   |--RPAREN -> ) [24:17]
+    |   `--SLIST -> { [25:4]
+    |       |--LITERAL_SYNCHRONIZED -> synchronized [26:8]
+    |       |   |--LPAREN -> ( [26:20]
+    |       |   |--EXPR -> EXPR [26:21]
+    |       |   |   `--LITERAL_THIS -> this [26:21]
+    |       |   |--RPAREN -> ) [26:25]
+    |       |   `--SLIST -> { [26:27]
+    |       |       `--RCURLY -> } [27:8]
+    |       |--LITERAL_TRY -> try [28:8]
+    |       |   |--SLIST -> { [28:11]
+    |       |   |   `--RCURLY -> } [29:8]
+    |       |   `--LITERAL_CATCH -> catch [30:8]
+    |       |       |--LPAREN -> ( [30:13]
+    |       |       |--PARAMETER_DEF -> PARAMETER_DEF [30:14]
+    |       |       |   |--MODIFIERS -> MODIFIERS [30:14]
+    |       |       |   |--TYPE -> TYPE [30:14]
+    |       |       |   |   `--IDENT -> RuntimeException [30:14]
+    |       |       |   `--IDENT -> e [30:31]
+    |       |       |--RPAREN -> ) [30:32]
+    |       |       `--SLIST -> { [30:33]
+    |       |           `--RCURLY -> } [31:8]
+    |       `--RCURLY -> } [32:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [40:4]
+    |   |--MODIFIERS -> MODIFIERS [40:4]
+    |   |   `--LITERAL_PRIVATE -> private [40:4]
+    |   |--TYPE -> TYPE [40:12]
+    |   |   `--LITERAL_INT -> int [40:12]
+    |   |--IDENT -> mVar4 [40:16]
+    |   |--ASSIGN -> = [40:22]
+    |   |   `--EXPR -> EXPR [40:24]
+    |   |       `--NUM_INT -> 1 [40:24]
+    |   `--SEMI -> ; [40:25]
+    |--METHOD_DEF -> METHOD_DEF [44:4]
+    |   |--MODIFIERS -> MODIFIERS [44:4]
+    |   |   `--LITERAL_PRIVATE -> private [44:4]
+    |   |--TYPE -> TYPE [44:12]
+    |   |   `--LITERAL_VOID -> void [44:12]
+    |   |--IDENT -> fastExit [44:17]
+    |   |--LPAREN -> ( [44:25]
+    |   |--PARAMETERS -> PARAMETERS [44:26]
+    |   |--RPAREN -> ) [44:26]
+    |   `--SLIST -> { [45:4]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [46:8]
+    |       |   |--MODIFIERS -> MODIFIERS [46:8]
+    |       |   |--TYPE -> TYPE [46:8]
+    |       |   |   `--LITERAL_BOOLEAN -> boolean [46:8]
+    |       |   |--IDENT -> complicatedStuffNeeded [46:16]
+    |       |   `--ASSIGN -> = [46:39]
+    |       |       `--EXPR -> EXPR [46:41]
+    |       |           `--LITERAL_TRUE -> true [46:41]
+    |       |--SEMI -> ; [46:45]
+    |       |--LITERAL_IF -> if [47:8]
+    |       |   |--LPAREN -> ( [47:10]
+    |       |   |--EXPR -> EXPR [47:12]
+    |       |   |   `--LNOT -> ! [47:12]
+    |       |   |       `--IDENT -> complicatedStuffNeeded [47:13]
+    |       |   |--RPAREN -> ) [47:36]
+    |       |   |--SLIST -> { [48:8]
+    |       |   |   |--LITERAL_RETURN -> return [49:12]
+    |       |   |   |   `--SEMI -> ; [49:18]
+    |       |   |   `--RCURLY -> } [50:8]
+    |       |   `--LITERAL_ELSE -> else [51:8]
+    |       |       `--SLIST -> { [52:8]
+    |       |           `--RCURLY -> } [54:8]
+    |       `--RCURLY -> } [55:4]
+    |--METHOD_DEF -> METHOD_DEF [61:4]
+    |   |--MODIFIERS -> MODIFIERS [61:4]
+    |   |   `--LITERAL_PRIVATE -> private [61:4]
+    |   |--TYPE -> TYPE [61:12]
+    |   |   `--LITERAL_INT -> int [61:12]
+    |   |--IDENT -> nonVoid [61:16]
+    |   |--LPAREN -> ( [61:23]
+    |   |--PARAMETERS -> PARAMETERS [61:24]
+    |   |--RPAREN -> ) [61:24]
+    |   `--SLIST -> { [62:4]
+    |       |--LITERAL_IF -> if [63:8]
+    |       |   |--LPAREN -> ( [63:11]
+    |       |   |--EXPR -> EXPR [63:13]
+    |       |   |   `--LITERAL_TRUE -> true [63:13]
+    |       |   |--RPAREN -> ) [63:18]
+    |       |   |--SLIST -> { [64:8]
+    |       |   |   |--LITERAL_RETURN -> return [65:12]
+    |       |   |   |   |--EXPR -> EXPR [65:18]
+    |       |   |   |   |   |--LPAREN -> ( [65:18]
+    |       |   |   |   |   |--NUM_INT -> 2 [65:19]
+    |       |   |   |   |   `--RPAREN -> ) [65:20]
+    |       |   |   |   `--SEMI -> ; [65:21]
+    |       |   |   `--RCURLY -> } [66:8]
+    |       |   `--LITERAL_ELSE -> else [67:8]
+    |       |       `--SLIST -> { [68:8]
+    |       |           |--LITERAL_RETURN -> return [69:12]
+    |       |           |   |--EXPR -> EXPR [69:19]
+    |       |           |   |   `--NUM_INT -> 2 [69:19]
+    |       |           |   `--SEMI -> ; [69:20]
+    |       |           `--RCURLY -> } [70:8]
+    |       `--RCURLY -> } [71:4]
+    |--METHOD_DEF -> METHOD_DEF [74:4]
+    |   |--MODIFIERS -> MODIFIERS [74:4]
+    |   |   `--LITERAL_PRIVATE -> private [74:4]
+    |   |--TYPE -> TYPE [74:12]
+    |   |   `--LITERAL_VOID -> void [74:12]
+    |   |--IDENT -> testCasts [74:17]
+    |   |--LPAREN -> ( [74:26]
+    |   |--PARAMETERS -> PARAMETERS [74:27]
+    |   |--RPAREN -> ) [74:27]
+    |   `--SLIST -> { [75:4]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [76:8]
+    |       |   |--MODIFIERS -> MODIFIERS [76:8]
+    |       |   |--TYPE -> TYPE [76:8]
+    |       |   |   `--IDENT -> Object [76:8]
+    |       |   |--IDENT -> o [76:15]
+    |       |   `--ASSIGN -> = [76:17]
+    |       |       `--EXPR -> EXPR [76:19]
+    |       |           `--TYPECAST -> ( [76:19]
+    |       |               |--TYPE -> TYPE [76:20]
+    |       |               |   `--IDENT -> Object [76:20]
+    |       |               |--RPAREN -> ) [76:26]
+    |       |               `--LITERAL_NEW -> new [76:28]
+    |       |                   |--IDENT -> Object [76:32]
+    |       |                   |--LPAREN -> ( [76:38]
+    |       |                   |--ELIST -> ELIST [76:39]
+    |       |                   `--RPAREN -> ) [76:39]
+    |       |--SEMI -> ; [76:40]
+    |       |--EXPR -> EXPR [77:10]
+    |       |   `--ASSIGN -> = [77:10]
+    |       |       |--IDENT -> o [77:8]
+    |       |       `--TYPECAST -> ( [77:12]
+    |       |           |--TYPE -> TYPE [77:13]
+    |       |           |   `--IDENT -> Object [77:13]
+    |       |           |--RPAREN -> ) [77:19]
+    |       |           `--IDENT -> o [77:20]
+    |       |--SEMI -> ; [77:21]
+    |       |--EXPR -> EXPR [78:10]
+    |       |   `--ASSIGN -> = [78:10]
+    |       |       |--IDENT -> o [78:8]
+    |       |       `--TYPECAST -> ( [78:12]
+    |       |           |--TYPE -> TYPE [78:14]
+    |       |           |   `--IDENT -> Object [78:14]
+    |       |           |--RPAREN -> ) [78:21]
+    |       |           `--IDENT -> o [78:23]
+    |       |--SEMI -> ; [78:24]
+    |       |--EXPR -> EXPR [79:10]
+    |       |   `--ASSIGN -> = [79:10]
+    |       |       |--IDENT -> o [79:8]
+    |       |       `--TYPECAST -> ( [79:12]
+    |       |           |--TYPE -> TYPE [79:13]
+    |       |           |   `--IDENT -> Object [79:13]
+    |       |           |--RPAREN -> ) [79:19]
+    |       |           `--IDENT -> o [80:12]
+    |       |--SEMI -> ; [80:13]
+    |       `--RCURLY -> } [81:4]
+    |--METHOD_DEF -> METHOD_DEF [84:4]
+    |   |--MODIFIERS -> MODIFIERS [84:4]
+    |   |   `--LITERAL_PRIVATE -> private [84:4]
+    |   |--TYPE -> TYPE [84:12]
+    |   |   `--LITERAL_VOID -> void [84:12]
+    |   |--IDENT -> testQuestions [84:17]
+    |   |--LPAREN -> ( [84:30]
+    |   |--PARAMETERS -> PARAMETERS [84:31]
+    |   |--RPAREN -> ) [84:31]
+    |   `--SLIST -> { [85:4]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [86:8]
+    |       |   |--MODIFIERS -> MODIFIERS [86:8]
+    |       |   |--TYPE -> TYPE [86:8]
+    |       |   |   `--LITERAL_BOOLEAN -> boolean [86:8]
+    |       |   |--IDENT -> b [86:16]
+    |       |   `--ASSIGN -> = [86:18]
+    |       |       `--EXPR -> EXPR [86:28]
+    |       |           `--QUESTION -> ? [86:28]
+    |       |               |--LPAREN -> ( [86:20]
+    |       |               |--EQUAL -> == [86:23]
+    |       |               |   |--NUM_INT -> 1 [86:21]
+    |       |               |   `--NUM_INT -> 2 [86:26]
+    |       |               |--RPAREN -> ) [86:27]
+    |       |               |--LITERAL_TRUE -> true [86:29]
+    |       |               |--COLON -> : [86:33]
+    |       |               `--LITERAL_FALSE -> false [86:34]
+    |       |--SEMI -> ; [86:39]
+    |       |--EXPR -> EXPR [87:10]
+    |       |   `--ASSIGN -> = [87:10]
+    |       |       |--IDENT -> b [87:8]
+    |       |       `--QUESTION -> ? [87:19]
+    |       |           |--LPAREN -> ( [87:12]
+    |       |           |--EQUAL -> == [87:14]
+    |       |           |   |--NUM_INT -> 1 [87:13]
+    |       |           |   `--NUM_INT -> 2 [87:16]
+    |       |           |--RPAREN -> ) [87:17]
+    |       |           |--LITERAL_FALSE -> false [87:21]
+    |       |           |--COLON -> : [87:27]
+    |       |           `--LITERAL_TRUE -> true [87:29]
+    |       |--SEMI -> ; [87:33]
+    |       `--RCURLY -> } [88:4]
+    |--METHOD_DEF -> METHOD_DEF [91:4]
+    |   |--MODIFIERS -> MODIFIERS [91:4]
+    |   |   `--LITERAL_PRIVATE -> private [91:4]
+    |   |--TYPE -> TYPE [91:12]
+    |   |   `--LITERAL_VOID -> void [91:12]
+    |   |--IDENT -> starTest [91:17]
+    |   |--LPAREN -> ( [91:25]
+    |   |--PARAMETERS -> PARAMETERS [91:26]
+    |   |--RPAREN -> ) [91:26]
+    |   `--SLIST -> { [92:4]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [93:8]
+    |       |   |--MODIFIERS -> MODIFIERS [93:8]
+    |       |   |--TYPE -> TYPE [93:8]
+    |       |   |   `--LITERAL_INT -> int [93:8]
+    |       |   |--IDENT -> x [93:12]
+    |       |   `--ASSIGN -> = [93:14]
+    |       |       `--EXPR -> EXPR [93:20]
+    |       |           `--STAR -> * [93:20]
+    |       |               |--STAR -> * [93:18]
+    |       |               |   |--NUM_INT -> 2 [93:16]
+    |       |               |   `--NUM_INT -> 3 [93:19]
+    |       |               `--NUM_INT -> 4 [93:22]
+    |       |--SEMI -> ; [93:23]
+    |       `--RCURLY -> } [94:4]
+    |--METHOD_DEF -> METHOD_DEF [97:4]
+    |   |--MODIFIERS -> MODIFIERS [97:4]
+    |   |   `--LITERAL_PRIVATE -> private [97:4]
+    |   |--TYPE -> TYPE [97:12]
+    |   |   `--LITERAL_VOID -> void [97:12]
+    |   |--IDENT -> boolTest [97:17]
+    |   |--LPAREN -> ( [97:25]
+    |   |--PARAMETERS -> PARAMETERS [97:26]
+    |   |--RPAREN -> ) [97:26]
+    |   `--SLIST -> { [98:4]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [99:8]
+    |       |   |--MODIFIERS -> MODIFIERS [99:8]
+    |       |   |--TYPE -> TYPE [99:8]
+    |       |   |   `--LITERAL_BOOLEAN -> boolean [99:8]
+    |       |   |--IDENT -> a [99:16]
+    |       |   `--ASSIGN -> = [99:18]
+    |       |       `--EXPR -> EXPR [99:20]
+    |       |           `--LITERAL_TRUE -> true [99:20]
+    |       |--SEMI -> ; [99:24]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [100:8]
+    |       |   |--MODIFIERS -> MODIFIERS [100:8]
+    |       |   |--TYPE -> TYPE [100:8]
+    |       |   |   `--LITERAL_BOOLEAN -> boolean [100:8]
+    |       |   |--IDENT -> x [100:16]
+    |       |   `--ASSIGN -> = [100:18]
+    |       |       `--EXPR -> EXPR [100:20]
+    |       |           `--LNOT -> ! [100:20]
+    |       |               `--IDENT -> a [100:22]
+    |       |--SEMI -> ; [100:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [101:8]
+    |       |   |--MODIFIERS -> MODIFIERS [101:8]
+    |       |   |--TYPE -> TYPE [101:8]
+    |       |   |   `--LITERAL_INT -> int [101:8]
+    |       |   |--IDENT -> z [101:12]
+    |       |   `--ASSIGN -> = [101:14]
+    |       |       `--EXPR -> EXPR [101:19]
+    |       |           `--PLUS -> + [101:19]
+    |       |               |--BNOT -> ~ [101:16]
+    |       |               |   `--NUM_INT -> 1 [101:17]
+    |       |               `--BNOT -> ~ [101:21]
+    |       |                   `--NUM_INT -> 2 [101:23]
+    |       |--SEMI -> ; [101:24]
+    |       `--RCURLY -> } [102:4]
+    |--METHOD_DEF -> METHOD_DEF [105:4]
+    |   |--MODIFIERS -> MODIFIERS [105:4]
+    |   |   `--LITERAL_PRIVATE -> private [105:4]
+    |   |--TYPE -> TYPE [105:12]
+    |   |   `--LITERAL_VOID -> void [105:12]
+    |   |--IDENT -> divTest [105:17]
+    |   |--LPAREN -> ( [105:24]
+    |   |--PARAMETERS -> PARAMETERS [105:25]
+    |   |--RPAREN -> ) [105:25]
+    |   `--SLIST -> { [106:4]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [107:8]
+    |       |   |--MODIFIERS -> MODIFIERS [107:8]
+    |       |   |--TYPE -> TYPE [107:8]
+    |       |   |   `--LITERAL_INT -> int [107:8]
+    |       |   |--IDENT -> a [107:12]
+    |       |   `--ASSIGN -> = [107:14]
+    |       |       `--EXPR -> EXPR [107:18]
+    |       |           `--MOD -> % [107:18]
+    |       |               |--NUM_INT -> 4 [107:16]
+    |       |               `--NUM_INT -> 2 [107:20]
+    |       |--SEMI -> ; [107:21]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [108:8]
+    |       |   |--MODIFIERS -> MODIFIERS [108:8]
+    |       |   |--TYPE -> TYPE [108:8]
+    |       |   |   `--LITERAL_INT -> int [108:8]
+    |       |   |--IDENT -> b [108:12]
+    |       |   `--ASSIGN -> = [108:14]
+    |       |       `--EXPR -> EXPR [108:17]
+    |       |           `--MOD -> % [108:17]
+    |       |               |--NUM_INT -> 4 [108:16]
+    |       |               `--NUM_INT -> 2 [108:19]
+    |       |--SEMI -> ; [108:20]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [109:8]
+    |       |   |--MODIFIERS -> MODIFIERS [109:8]
+    |       |   |--TYPE -> TYPE [109:8]
+    |       |   |   `--LITERAL_INT -> int [109:8]
+    |       |   |--IDENT -> c [109:12]
+    |       |   `--ASSIGN -> = [109:14]
+    |       |       `--EXPR -> EXPR [109:18]
+    |       |           `--MOD -> % [109:18]
+    |       |               |--NUM_INT -> 4 [109:16]
+    |       |               `--NUM_INT -> 2 [109:19]
+    |       |--SEMI -> ; [109:20]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [110:8]
+    |       |   |--MODIFIERS -> MODIFIERS [110:8]
+    |       |   |--TYPE -> TYPE [110:8]
+    |       |   |   `--LITERAL_INT -> int [110:8]
+    |       |   |--IDENT -> d [110:12]
+    |       |   `--ASSIGN -> = [110:14]
+    |       |       `--EXPR -> EXPR [110:17]
+    |       |           `--MOD -> % [110:17]
+    |       |               |--NUM_INT -> 4 [110:16]
+    |       |               `--NUM_INT -> 2 [110:18]
+    |       |--SEMI -> ; [110:19]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [111:8]
+    |       |   |--MODIFIERS -> MODIFIERS [111:8]
+    |       |   |--TYPE -> TYPE [111:8]
+    |       |   |   `--LITERAL_INT -> int [111:8]
+    |       |   |--IDENT -> e [111:12]
+    |       |   `--ASSIGN -> = [111:14]
+    |       |       `--EXPR -> EXPR [111:18]
+    |       |           `--DIV -> / [111:18]
+    |       |               |--NUM_INT -> 4 [111:16]
+    |       |               `--NUM_INT -> 2 [111:20]
+    |       |--SEMI -> ; [111:21]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [112:8]
+    |       |   |--MODIFIERS -> MODIFIERS [112:8]
+    |       |   |--TYPE -> TYPE [112:8]
+    |       |   |   `--LITERAL_INT -> int [112:8]
+    |       |   |--IDENT -> f [112:12]
+    |       |   `--ASSIGN -> = [112:14]
+    |       |       `--EXPR -> EXPR [112:17]
+    |       |           `--DIV -> / [112:17]
+    |       |               |--NUM_INT -> 4 [112:16]
+    |       |               `--NUM_INT -> 2 [112:19]
+    |       |--SEMI -> ; [112:20]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [113:8]
+    |       |   |--MODIFIERS -> MODIFIERS [113:8]
+    |       |   |--TYPE -> TYPE [113:8]
+    |       |   |   `--LITERAL_INT -> int [113:8]
+    |       |   |--IDENT -> g [113:12]
+    |       |   `--ASSIGN -> = [113:14]
+    |       |       `--EXPR -> EXPR [113:18]
+    |       |           `--DIV -> / [113:18]
+    |       |               |--NUM_INT -> 4 [113:16]
+    |       |               `--NUM_INT -> 2 [113:19]
+    |       |--SEMI -> ; [113:20]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [114:8]
+    |       |   |--MODIFIERS -> MODIFIERS [114:8]
+    |       |   |--TYPE -> TYPE [114:8]
+    |       |   |   `--LITERAL_INT -> int [114:8]
+    |       |   |--IDENT -> h [114:12]
+    |       |   `--ASSIGN -> = [114:14]
+    |       |       `--EXPR -> EXPR [114:17]
+    |       |           `--DIV -> / [114:17]
+    |       |               |--NUM_INT -> 4 [114:16]
+    |       |               `--NUM_INT -> 2 [114:18]
+    |       |--SEMI -> ; [114:19]
+    |       `--RCURLY -> } [115:4]
+    |--METHOD_DEF -> METHOD_DEF [118:4]
+    |   |--MODIFIERS -> MODIFIERS [118:4]
+    |   |   `--LITERAL_PRIVATE -> private [118:4]
+    |   |--TYPE -> TYPE [118:22]
+    |   |   `--DOT -> . [118:22]
+    |   |       |--DOT -> . [118:17]
+    |   |       |   |--IDENT -> java [118:12]
+    |   |       |   `--IDENT -> lang [118:18]
+    |   |       `--IDENT -> String [118:25]
+    |   |--IDENT -> dotTest [118:32]
+    |   |--LPAREN -> ( [118:39]
+    |   |--PARAMETERS -> PARAMETERS [118:40]
+    |   |--RPAREN -> ) [118:40]
+    |   `--SLIST -> { [119:4]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [120:8]
+    |       |   |--MODIFIERS -> MODIFIERS [120:8]
+    |       |   |--TYPE -> TYPE [120:8]
+    |       |   |   `--IDENT -> Object [120:8]
+    |       |   |--IDENT -> o [120:15]
+    |       |   `--ASSIGN -> = [120:17]
+    |       |       `--EXPR -> EXPR [120:19]
+    |       |           `--LITERAL_NEW -> new [120:19]
+    |       |               |--DOT -> . [120:32]
+    |       |               |   |--DOT -> . [120:27]
+    |       |               |   |   |--IDENT -> java [120:23]
+    |       |               |   |   `--IDENT -> lang [120:28]
+    |       |               |   `--IDENT -> Object [120:33]
+    |       |               |--LPAREN -> ( [120:39]
+    |       |               |--ELIST -> ELIST [120:40]
+    |       |               `--RPAREN -> ) [120:40]
+    |       |--SEMI -> ; [120:41]
+    |       |--EXPR -> EXPR [122:20]
+    |       |   `--METHOD_CALL -> ( [122:20]
+    |       |       |--DOT -> . [121:9]
+    |       |       |   |--IDENT -> o [121:8]
+    |       |       |   `--IDENT -> toString [122:12]
+    |       |       |--ELIST -> ELIST [122:21]
+    |       |       `--RPAREN -> ) [122:21]
+    |       |--SEMI -> ; [122:22]
+    |       |--EXPR -> EXPR [124:21]
+    |       |   `--METHOD_CALL -> ( [124:21]
+    |       |       |--DOT -> . [124:12]
+    |       |       |   |--IDENT -> o [123:8]
+    |       |       |   `--IDENT -> toString [124:13]
+    |       |       |--ELIST -> ELIST [124:22]
+    |       |       `--RPAREN -> ) [124:22]
+    |       |--SEMI -> ; [124:23]
+    |       |--EXPR -> EXPR [125:20]
+    |       |   `--METHOD_CALL -> ( [125:20]
+    |       |       |--DOT -> . [125:10]
+    |       |       |   |--IDENT -> o [125:8]
+    |       |       |   `--IDENT -> toString [125:12]
+    |       |       |--ELIST -> ELIST [125:21]
+    |       |       `--RPAREN -> ) [125:21]
+    |       |--SEMI -> ; [125:22]
+    |       |--LITERAL_RETURN -> return [126:8]
+    |       |   |--EXPR -> EXPR [126:25]
+    |       |   |   `--METHOD_CALL -> ( [126:25]
+    |       |   |       |--DOT -> . [126:16]
+    |       |   |       |   |--IDENT -> o [126:15]
+    |       |   |       |   `--IDENT -> toString [126:17]
+    |       |   |       |--ELIST -> ELIST [126:26]
+    |       |   |       `--RPAREN -> ) [126:26]
+    |       |   `--SEMI -> ; [126:27]
+    |       `--RCURLY -> } [127:4]
+    |--METHOD_DEF -> METHOD_DEF [130:4]
+    |   |--MODIFIERS -> MODIFIERS [130:4]
+    |   |   `--LITERAL_PUBLIC -> public [130:4]
+    |   |--TYPE -> TYPE [130:11]
+    |   |   `--LITERAL_VOID -> void [130:11]
+    |   |--IDENT -> assertTest [130:16]
+    |   |--LPAREN -> ( [130:26]
+    |   |--PARAMETERS -> PARAMETERS [130:27]
+    |   |--RPAREN -> ) [130:27]
+    |   `--SLIST -> { [131:4]
+    |       |--LITERAL_ASSERT -> assert [133:8]
+    |       |   |--EXPR -> EXPR [133:15]
+    |       |   |   `--LITERAL_TRUE -> true [133:15]
+    |       |   `--SEMI -> ; [133:19]
+    |       |--LITERAL_ASSERT -> assert [136:8]
+    |       |   |--EXPR -> EXPR [136:15]
+    |       |   |   `--LITERAL_TRUE -> true [136:15]
+    |       |   |--COLON -> : [136:20]
+    |       |   |--EXPR -> EXPR [136:22]
+    |       |   |   `--STRING_LITERAL -> "Whups" [136:22]
+    |       |   `--SEMI -> ; [136:29]
+    |       |--LITERAL_ASSERT -> assert [139:8]
+    |       |   |--EXPR -> EXPR [139:33]
+    |       |   |   `--QUESTION -> ? [139:33]
+    |       |   |       |--METHOD_CALL -> ( [139:26]
+    |       |   |       |   |--DOT -> . [139:19]
+    |       |   |       |   |   |--STRING_LITERAL -> "OK" [139:15]
+    |       |   |       |   |   `--IDENT -> equals [139:20]
+    |       |   |       |   |--ELIST -> ELIST [139:27]
+    |       |   |       |   |   `--EXPR -> EXPR [139:27]
+    |       |   |       |   |       `--LITERAL_NULL -> null [139:27]
+    |       |   |       |   `--RPAREN -> ) [139:31]
+    |       |   |       |--LITERAL_FALSE -> false [139:35]
+    |       |   |       |--COLON -> : [139:41]
+    |       |   |       `--LITERAL_TRUE -> true [139:43]
+    |       |   |--COLON -> : [139:48]
+    |       |   |--EXPR -> EXPR [139:50]
+    |       |   |   `--STRING_LITERAL -> "Whups" [139:50]
+    |       |   `--SEMI -> ; [139:57]
+    |       |--LITERAL_ASSERT -> assert [142:8]
+    |       |   |--EXPR -> EXPR [142:14]
+    |       |   |   |--LPAREN -> ( [142:14]
+    |       |   |   |--LITERAL_TRUE -> true [142:15]
+    |       |   |   `--RPAREN -> ) [142:19]
+    |       |   `--SEMI -> ; [142:20]
+    |       |--LITERAL_ASSERT -> assert [145:8]
+    |       |   |--EXPR -> EXPR [145:15]
+    |       |   |   `--LITERAL_TRUE -> true [145:15]
+    |       |   |--COLON -> : [145:19]
+    |       |   |--EXPR -> EXPR [145:20]
+    |       |   |   `--STRING_LITERAL -> "Whups" [145:20]
+    |       |   `--SEMI -> ; [145:27]
+    |       `--RCURLY -> } [146:4]
+    |--METHOD_DEF -> METHOD_DEF [149:4]
+    |   |--MODIFIERS -> MODIFIERS [149:4]
+    |   |--TYPE -> TYPE [149:4]
+    |   |   `--LITERAL_VOID -> void [149:4]
+    |   |--IDENT -> donBradman [149:9]
+    |   |--LPAREN -> ( [149:19]
+    |   |--PARAMETERS -> PARAMETERS [149:20]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [149:20]
+    |   |       |--MODIFIERS -> MODIFIERS [149:20]
+    |   |       |--TYPE -> TYPE [149:20]
+    |   |       |   `--IDENT -> Runnable [149:20]
+    |   |       `--IDENT -> aRun [149:29]
+    |   |--RPAREN -> ) [149:33]
+    |   `--SLIST -> { [150:4]
+    |       |--EXPR -> EXPR [151:18]
+    |       |   `--METHOD_CALL -> ( [151:18]
+    |       |       |--IDENT -> donBradman [151:8]
+    |       |       |--ELIST -> ELIST [151:19]
+    |       |       |   `--EXPR -> EXPR [151:19]
+    |       |       |       `--LITERAL_NEW -> new [151:19]
+    |       |       |           |--IDENT -> Runnable [151:23]
+    |       |       |           |--LPAREN -> ( [151:31]
+    |       |       |           |--ELIST -> ELIST [151:32]
+    |       |       |           |--RPAREN -> ) [151:32]
+    |       |       |           `--OBJBLOCK -> OBJBLOCK [151:34]
+    |       |       |               |--LCURLY -> { [151:34]
+    |       |       |               |--METHOD_DEF -> METHOD_DEF [152:12]
+    |       |       |               |   |--MODIFIERS -> MODIFIERS [152:12]
+    |       |       |               |   |   `--LITERAL_PUBLIC -> public [152:12]
+    |       |       |               |   |--TYPE -> TYPE [152:19]
+    |       |       |               |   |   `--LITERAL_VOID -> void [152:19]
+    |       |       |               |   |--IDENT -> run [152:24]
+    |       |       |               |   |--LPAREN -> ( [152:27]
+    |       |       |               |   |--PARAMETERS -> PARAMETERS [152:28]
+    |       |       |               |   |--RPAREN -> ) [152:28]
+    |       |       |               |   `--SLIST -> { [152:30]
+    |       |       |               |       `--RCURLY -> } [153:12]
+    |       |       |               `--RCURLY -> } [154:8]
+    |       |       `--RPAREN -> ) [154:9]
+    |       |--SEMI -> ; [154:10]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [156:8]
+    |       |   |--MODIFIERS -> MODIFIERS [156:8]
+    |       |   |   `--FINAL -> final [156:8]
+    |       |   |--TYPE -> TYPE [156:14]
+    |       |   |   `--IDENT -> Runnable [156:14]
+    |       |   |--IDENT -> r [156:23]
+    |       |   `--ASSIGN -> = [156:25]
+    |       |       `--EXPR -> EXPR [156:27]
+    |       |           `--LITERAL_NEW -> new [156:27]
+    |       |               |--IDENT -> Runnable [156:31]
+    |       |               |--LPAREN -> ( [156:39]
+    |       |               |--ELIST -> ELIST [156:40]
+    |       |               |--RPAREN -> ) [156:40]
+    |       |               `--OBJBLOCK -> OBJBLOCK [156:42]
+    |       |                   |--LCURLY -> { [156:42]
+    |       |                   |--METHOD_DEF -> METHOD_DEF [157:12]
+    |       |                   |   |--MODIFIERS -> MODIFIERS [157:12]
+    |       |                   |   |   `--LITERAL_PUBLIC -> public [157:12]
+    |       |                   |   |--TYPE -> TYPE [157:19]
+    |       |                   |   |   `--LITERAL_VOID -> void [157:19]
+    |       |                   |   |--IDENT -> run [157:24]
+    |       |                   |   |--LPAREN -> ( [157:27]
+    |       |                   |   |--PARAMETERS -> PARAMETERS [157:28]
+    |       |                   |   |--RPAREN -> ) [157:28]
+    |       |                   |   `--SLIST -> { [157:30]
+    |       |                   |       `--RCURLY -> } [158:12]
+    |       |                   `--RCURLY -> } [159:8]
+    |       |--SEMI -> ; [159:9]
+    |       `--RCURLY -> } [160:4]
+    |--METHOD_DEF -> METHOD_DEF [163:4]
+    |   |--MODIFIERS -> MODIFIERS [163:4]
+    |   |--TYPE -> TYPE [163:4]
+    |   |   `--LITERAL_VOID -> void [163:4]
+    |   |--IDENT -> rfe521323 [163:9]
+    |   |--LPAREN -> ( [163:18]
+    |   |--PARAMETERS -> PARAMETERS [163:19]
+    |   |--RPAREN -> ) [163:19]
+    |   `--SLIST -> { [164:4]
+    |       |--EXPR -> EXPR [165:15]
+    |       |   `--METHOD_CALL -> ( [165:15]
+    |       |       |--IDENT -> doStuff [165:8]
+    |       |       |--ELIST -> ELIST [165:16]
+    |       |       `--RPAREN -> ) [165:16]
+    |       |--SEMI -> ; [165:18]
+    |       |--LITERAL_FOR -> for [167:8]
+    |       |   |--LPAREN -> ( [167:12]
+    |       |   |--FOR_INIT -> FOR_INIT [167:13]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [167:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [167:13]
+    |       |   |       |--TYPE -> TYPE [167:13]
+    |       |   |       |   `--LITERAL_INT -> int [167:13]
+    |       |   |       |--IDENT -> i [167:17]
+    |       |   |       `--ASSIGN -> = [167:19]
+    |       |   |           `--EXPR -> EXPR [167:21]
+    |       |   |               `--NUM_INT -> 0 [167:21]
+    |       |   |--SEMI -> ; [167:23]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [167:27]
+    |       |   |   `--EXPR -> EXPR [167:27]
+    |       |   |       `--LT -> < [167:27]
+    |       |   |           |--IDENT -> i [167:25]
+    |       |   |           `--NUM_INT -> 5 [167:29]
+    |       |   |--SEMI -> ; [167:30]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [167:33]
+    |       |   |   `--ELIST -> ELIST [167:33]
+    |       |   |       `--EXPR -> EXPR [167:33]
+    |       |   |           `--POST_INC -> ++ [167:33]
+    |       |   |               `--IDENT -> i [167:32]
+    |       |   |--RPAREN -> ) [167:35]
+    |       |   `--SLIST -> { [167:37]
+    |       |       `--RCURLY -> } [169:8]
+    |       `--RCURLY -> } [170:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [174:4]
+    |   |--MODIFIERS -> MODIFIERS [174:4]
+    |   |   `--LITERAL_PRIVATE -> private [174:4]
+    |   |--TYPE -> TYPE [174:12]
+    |   |   `--LITERAL_INT -> int [174:12]
+    |   |--IDENT -> i [174:16]
+    |   `--SEMI -> ; [174:18]
+    |--VARIABLE_DEF -> VARIABLE_DEF [176:4]
+    |   |--MODIFIERS -> MODIFIERS [176:4]
+    |   |   `--LITERAL_PRIVATE -> private [176:4]
+    |   |--TYPE -> TYPE [176:12]
+    |   |   `--LITERAL_INT -> int [176:12]
+    |   |--IDENT -> i1 [176:16]
+    |   `--SEMI -> ; [176:27]
+    |--COMMA -> , [176:18]
+    |--VARIABLE_DEF -> VARIABLE_DEF [176:4]
+    |   |--MODIFIERS -> MODIFIERS [176:4]
+    |   |   `--LITERAL_PRIVATE -> private [176:4]
+    |   |--TYPE -> TYPE [176:12]
+    |   |   `--LITERAL_INT -> int [176:12]
+    |   `--IDENT -> i2 [176:20]
+    |--COMMA -> , [176:22]
+    |--VARIABLE_DEF -> VARIABLE_DEF [176:4]
+    |   |--MODIFIERS -> MODIFIERS [176:4]
+    |   |   `--LITERAL_PRIVATE -> private [176:4]
+    |   |--TYPE -> TYPE [176:12]
+    |   |   `--LITERAL_INT -> int [176:12]
+    |   `--IDENT -> i3 [176:24]
+    |--VARIABLE_DEF -> VARIABLE_DEF [178:4]
+    |   |--MODIFIERS -> MODIFIERS [178:4]
+    |   |   `--LITERAL_PRIVATE -> private [178:4]
+    |   |--TYPE -> TYPE [178:12]
+    |   |   `--LITERAL_INT -> int [178:12]
+    |   |--IDENT -> i4 [178:16]
+    |   `--SEMI -> ; [178:26]
+    |--COMMA -> , [178:18]
+    |--VARIABLE_DEF -> VARIABLE_DEF [178:4]
+    |   |--MODIFIERS -> MODIFIERS [178:4]
+    |   |   `--LITERAL_PRIVATE -> private [178:4]
+    |   |--TYPE -> TYPE [178:12]
+    |   |   `--LITERAL_INT -> int [178:12]
+    |   `--IDENT -> i5 [178:20]
+    |--COMMA -> , [178:22]
+    |--VARIABLE_DEF -> VARIABLE_DEF [178:4]
+    |   |--MODIFIERS -> MODIFIERS [178:4]
+    |   |   `--LITERAL_PRIVATE -> private [178:4]
+    |   |--TYPE -> TYPE [178:12]
+    |   |   `--LITERAL_INT -> int [178:12]
+    |   `--IDENT -> i6 [178:24]
+    |--METHOD_DEF -> METHOD_DEF [181:4]
+    |   |--MODIFIERS -> MODIFIERS [181:4]
+    |   |--TYPE -> TYPE [181:4]
+    |   |   `--LITERAL_VOID -> void [181:4]
+    |   |--IDENT -> bug806243 [181:9]
+    |   |--LPAREN -> ( [181:18]
+    |   |--PARAMETERS -> PARAMETERS [181:19]
+    |   |--RPAREN -> ) [181:19]
+    |   `--SLIST -> { [182:4]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [183:8]
+    |       |   |--MODIFIERS -> MODIFIERS [183:8]
+    |       |   |--TYPE -> TYPE [183:8]
+    |       |   |   `--IDENT -> Object [183:8]
+    |       |   |--IDENT -> o [183:15]
+    |       |   `--ASSIGN -> = [183:17]
+    |       |       `--EXPR -> EXPR [183:19]
+    |       |           `--LITERAL_NEW -> new [183:19]
+    |       |               |--IDENT -> InputAntlr4AstRegressionKeywordsAndOperators [183:23]
+    |       |               |--LPAREN -> ( [183:67]
+    |       |               |--ELIST -> ELIST [183:68]
+    |       |               |--RPAREN -> ) [183:68]
+    |       |               `--OBJBLOCK -> OBJBLOCK [183:70]
+    |       |                   |--LCURLY -> { [183:70]
+    |       |                   |--VARIABLE_DEF -> VARIABLE_DEF [184:12]
+    |       |                   |   |--MODIFIERS -> MODIFIERS [184:12]
+    |       |                   |   |   `--LITERAL_PRIVATE -> private [184:12]
+    |       |                   |   |--TYPE -> TYPE [184:20]
+    |       |                   |   |   `--LITERAL_INT -> int [184:20]
+    |       |                   |   |--IDENT -> j [184:24]
+    |       |                   |   `--SEMI -> ; [184:26]
+    |       |                   `--RCURLY -> } [186:8]
+    |       |--SEMI -> ; [186:9]
+    |       `--RCURLY -> } [187:4]
+    |--METHOD_DEF -> METHOD_DEF [189:4]
+    |   |--MODIFIERS -> MODIFIERS [189:4]
+    |   |--TYPE -> TYPE [189:4]
+    |   |   `--LITERAL_VOID -> void [189:4]
+    |   |--IDENT -> doStuff [189:9]
+    |   |--LPAREN -> ( [189:16]
+    |   |--PARAMETERS -> PARAMETERS [189:17]
+    |   |--RPAREN -> ) [189:17]
+    |   `--SLIST -> { [189:19]
+    |       `--RCURLY -> } [190:4]
+    `--RCURLY -> } [191:0]
+INTERFACE_DEF -> INTERFACE_DEF [198:0]
+|--MODIFIERS -> MODIFIERS [198:0]
+|--LITERAL_INTERFACE -> interface [198:0]
+|--IDENT -> IFoo [198:10]
+`--OBJBLOCK -> OBJBLOCK [199:0]
+    |--LCURLY -> { [199:0]
+    |--METHOD_DEF -> METHOD_DEF [200:4]
+    |   |--MODIFIERS -> MODIFIERS [200:4]
+    |   |--TYPE -> TYPE [200:4]
+    |   |   `--LITERAL_VOID -> void [200:4]
+    |   |--IDENT -> foo [200:9]
+    |   |--LPAREN -> ( [200:12]
+    |   |--PARAMETERS -> PARAMETERS [200:13]
+    |   |--RPAREN -> ) [200:13]
+    |   `--SEMI -> ; [200:15]
+    `--RCURLY -> } [202:0]
+CLASS_DEF -> CLASS_DEF [209:0]
+|--MODIFIERS -> MODIFIERS [209:0]
+|--LITERAL_CLASS -> class [209:0]
+|--IDENT -> SpecialCasesInForLoop [209:6]
+`--OBJBLOCK -> OBJBLOCK [210:0]
+    |--LCURLY -> { [210:0]
+    |--METHOD_DEF -> METHOD_DEF [211:4]
+    |   |--MODIFIERS -> MODIFIERS [211:4]
+    |   |--TYPE -> TYPE [211:4]
+    |   |   `--LITERAL_VOID -> void [211:4]
+    |   |--IDENT -> forIterator [211:9]
+    |   |--LPAREN -> ( [211:20]
+    |   |--PARAMETERS -> PARAMETERS [211:21]
+    |   |--RPAREN -> ) [211:21]
+    |   `--SLIST -> { [212:4]
+    |       |--LITERAL_FOR -> for [214:8]
+    |       |   |--LPAREN -> ( [214:12]
+    |       |   |--FOR_INIT -> FOR_INIT [214:13]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [214:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [214:13]
+    |       |   |       |--TYPE -> TYPE [214:13]
+    |       |   |       |   `--LITERAL_INT -> int [214:13]
+    |       |   |       |--IDENT -> i [214:17]
+    |       |   |       `--ASSIGN -> = [214:19]
+    |       |   |           `--EXPR -> EXPR [214:21]
+    |       |   |               `--NUM_INT -> 0 [214:21]
+    |       |   |--SEMI -> ; [214:22]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [214:28]
+    |       |   |   `--EXPR -> EXPR [214:28]
+    |       |   |       `--LT -> < [214:28]
+    |       |   |           |--POST_INC -> ++ [214:25]
+    |       |   |           |   `--IDENT -> i [214:24]
+    |       |   |           `--NUM_INT -> 5 [214:30]
+    |       |   |--SEMI -> ; [214:31]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [214:32]
+    |       |   |--RPAREN -> ) [214:32]
+    |       |   `--SLIST -> { [214:34]
+    |       |       `--RCURLY -> } [216:4]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [220:4]
+    |       |   |--MODIFIERS -> MODIFIERS [220:4]
+    |       |   |--TYPE -> TYPE [220:4]
+    |       |   |   `--LITERAL_INT -> int [220:4]
+    |       |   |--IDENT -> i [220:8]
+    |       |   `--ASSIGN -> = [220:10]
+    |       |       `--EXPR -> EXPR [220:12]
+    |       |           `--NUM_INT -> 0 [220:12]
+    |       |--SEMI -> ; [220:13]
+    |       |--LITERAL_FOR -> for [221:4]
+    |       |   |--LPAREN -> ( [221:8]
+    |       |   |--FOR_INIT -> FOR_INIT [221:10]
+    |       |   |--SEMI -> ; [221:10]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [221:14]
+    |       |   |   `--EXPR -> EXPR [221:14]
+    |       |   |       `--LT -> < [221:14]
+    |       |   |           |--IDENT -> i [221:12]
+    |       |   |           `--NUM_INT -> 5 [221:16]
+    |       |   |--SEMI -> ; [221:17]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [221:20]
+    |       |   |   `--ELIST -> ELIST [221:20]
+    |       |   |       `--EXPR -> EXPR [221:20]
+    |       |   |           `--POST_INC -> ++ [221:20]
+    |       |   |               `--IDENT -> i [221:19]
+    |       |   |--RPAREN -> ) [221:23]
+    |       |   `--SLIST -> { [221:25]
+    |       |       `--RCURLY -> } [223:4]
+    |       |--LITERAL_FOR -> for [224:8]
+    |       |   |--LPAREN -> ( [224:12]
+    |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [224:13]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [224:13]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [224:13]
+    |       |   |   |   |--TYPE -> TYPE [224:13]
+    |       |   |   |   |   `--LITERAL_INT -> int [224:13]
+    |       |   |   |   `--IDENT -> anInt [224:17]
+    |       |   |   |--COLON -> : [224:23]
+    |       |   |   `--EXPR -> EXPR [224:36]
+    |       |   |       `--METHOD_CALL -> ( [224:36]
+    |       |   |           |--IDENT -> getSomeInts [224:25]
+    |       |   |           |--ELIST -> ELIST [224:37]
+    |       |   |           `--RPAREN -> ) [224:37]
+    |       |   |--RPAREN -> ) [224:38]
+    |       |   `--SLIST -> { [224:40]
+    |       |       `--RCURLY -> } [226:8]
+    |       `--RCURLY -> } [227:4]
+    |--METHOD_DEF -> METHOD_DEF [229:4]
+    |   |--MODIFIERS -> MODIFIERS [229:4]
+    |   |--TYPE -> TYPE [229:4]
+    |   |   |--LITERAL_INT -> int [229:4]
+    |   |   `--ARRAY_DECLARATOR -> [ [229:7]
+    |   |       `--RBRACK -> ] [229:8]
+    |   |--IDENT -> getSomeInts [229:10]
+    |   |--LPAREN -> ( [229:21]
+    |   |--PARAMETERS -> PARAMETERS [229:22]
+    |   |--RPAREN -> ) [229:22]
+    |   `--SLIST -> { [229:24]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [230:8]
+    |       |   |--MODIFIERS -> MODIFIERS [230:8]
+    |       |   |--TYPE -> TYPE [230:8]
+    |       |   |   `--LITERAL_INT -> int [230:8]
+    |       |   |--IDENT -> i [230:12]
+    |       |   `--ASSIGN -> = [230:14]
+    |       |       `--EXPR -> EXPR [230:16]
+    |       |           `--TYPECAST -> ( [230:16]
+    |       |               |--TYPE -> TYPE [230:17]
+    |       |               |   `--LITERAL_INT -> int [230:17]
+    |       |               |--RPAREN -> ) [230:20]
+    |       |               |--LPAREN -> ( [230:22]
+    |       |               |--DIV -> / [230:26]
+    |       |               |   |--NUM_INT -> 2 [230:24]
+    |       |               |   `--NUM_INT -> 3 [230:28]
+    |       |               `--RPAREN -> ) [230:30]
+    |       |--SEMI -> ; [230:31]
+    |       |--LITERAL_RETURN -> return [231:8]
+    |       |   |--EXPR -> EXPR [231:15]
+    |       |   |   `--LITERAL_NULL -> null [231:15]
+    |       |   `--SEMI -> ; [231:19]
+    |       `--RCURLY -> } [232:4]
+    |--METHOD_DEF -> METHOD_DEF [234:4]
+    |   |--MODIFIERS -> MODIFIERS [234:4]
+    |   |   `--LITERAL_PUBLIC -> public [234:4]
+    |   |--TYPE -> TYPE [234:11]
+    |   |   `--LITERAL_VOID -> void [234:11]
+    |   |--IDENT -> myMethod [234:16]
+    |   |--LPAREN -> ( [234:24]
+    |   |--PARAMETERS -> PARAMETERS [234:25]
+    |   |--RPAREN -> ) [234:25]
+    |   `--SLIST -> { [234:27]
+    |       |--EXPR -> EXPR [238:15]
+    |       |   `--METHOD_CALL -> ( [238:15]
+    |       |       |--DOT -> . [238:9]
+    |       |       |   |--LITERAL_NEW -> new [235:8]
+    |       |       |   |   |--IDENT -> Thread [235:12]
+    |       |       |   |   |--LPAREN -> ( [235:18]
+    |       |       |   |   |--ELIST -> ELIST [235:19]
+    |       |       |   |   |--RPAREN -> ) [235:19]
+    |       |       |   |   `--OBJBLOCK -> OBJBLOCK [235:21]
+    |       |       |   |       |--LCURLY -> { [235:21]
+    |       |       |   |       |--METHOD_DEF -> METHOD_DEF [236:12]
+    |       |       |   |       |   |--MODIFIERS -> MODIFIERS [236:12]
+    |       |       |   |       |   |   `--LITERAL_PUBLIC -> public [236:12]
+    |       |       |   |       |   |--TYPE -> TYPE [236:19]
+    |       |       |   |       |   |   `--LITERAL_VOID -> void [236:19]
+    |       |       |   |       |   |--IDENT -> run [236:24]
+    |       |       |   |       |   |--LPAREN -> ( [236:27]
+    |       |       |   |       |   |--PARAMETERS -> PARAMETERS [236:28]
+    |       |       |   |       |   |--RPAREN -> ) [236:28]
+    |       |       |   |       |   `--SLIST -> { [236:30]
+    |       |       |   |       |       `--RCURLY -> } [237:12]
+    |       |       |   |       `--RCURLY -> } [238:8]
+    |       |       |   `--IDENT -> start [238:10]
+    |       |       |--ELIST -> ELIST [238:16]
+    |       |       `--RPAREN -> ) [238:16]
+    |       |--SEMI -> ; [238:17]
+    |       `--RCURLY -> } [239:4]
+    |--METHOD_DEF -> METHOD_DEF [241:4]
+    |   |--MODIFIERS -> MODIFIERS [241:4]
+    |   |   `--LITERAL_PUBLIC -> public [241:4]
+    |   |--TYPE -> TYPE [241:11]
+    |   |   `--LITERAL_VOID -> void [241:11]
+    |   |--IDENT -> foo [241:16]
+    |   |--LPAREN -> ( [241:19]
+    |   |--PARAMETERS -> PARAMETERS [241:29]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [241:29]
+    |   |   |   |--MODIFIERS -> MODIFIERS [241:29]
+    |   |   |   |--TYPE -> TYPE [241:29]
+    |   |   |   |   `--DOT -> . [241:29]
+    |   |   |   |       |--DOT -> . [241:24]
+    |   |   |   |       |   |--IDENT -> java [241:20]
+    |   |   |   |       |   `--IDENT -> util [241:25]
+    |   |   |   |       |--IDENT -> List [241:30]
+    |   |   |   |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [241:34]
+    |   |   |   |           |--GENERIC_START -> < [241:34]
+    |   |   |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [241:35]
+    |   |   |   |           |   |--WILDCARD_TYPE -> ? [241:35]
+    |   |   |   |           |   `--TYPE_UPPER_BOUNDS -> extends [241:37]
+    |   |   |   |           |       |--IDENT -> String [241:45]
+    |   |   |   |           |       `--ARRAY_DECLARATOR -> [ [241:51]
+    |   |   |   |           |           `--RBRACK -> ] [241:52]
+    |   |   |   |           `--GENERIC_END -> > [241:53]
+    |   |   |   `--IDENT -> bar [241:55]
+    |   |   |--COMMA -> , [241:58]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [241:60]
+    |   |       |--MODIFIERS -> MODIFIERS [241:60]
+    |   |       |--TYPE -> TYPE [241:60]
+    |   |       |   |--IDENT -> Comparable [241:60]
+    |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [241:70]
+    |   |       |       |--GENERIC_START -> < [241:70]
+    |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [241:71]
+    |   |       |       |   |--WILDCARD_TYPE -> ? [241:71]
+    |   |       |       |   `--TYPE_LOWER_BOUNDS -> super [241:73]
+    |   |       |       |       |--IDENT -> Object [241:79]
+    |   |       |       |       `--ARRAY_DECLARATOR -> [ [241:85]
+    |   |       |       |           `--RBRACK -> ] [241:86]
+    |   |       |       `--GENERIC_END -> > [241:87]
+    |   |       `--IDENT -> baz [241:89]
+    |   |--RPAREN -> ) [241:92]
+    |   `--SLIST -> { [241:94]
+    |       `--RCURLY -> } [241:96]
+    |--METHOD_DEF -> METHOD_DEF [243:4]
+    |   |--MODIFIERS -> MODIFIERS [243:4]
+    |   |   `--LITERAL_PUBLIC -> public [243:4]
+    |   |--TYPE -> TYPE [243:11]
+    |   |   `--LITERAL_VOID -> void [243:11]
+    |   |--IDENT -> mySuperMethod [243:16]
+    |   |--LPAREN -> ( [243:29]
+    |   |--PARAMETERS -> PARAMETERS [243:30]
+    |   |--RPAREN -> ) [243:30]
+    |   `--SLIST -> { [243:32]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [244:8]
+    |       |   |--MODIFIERS -> MODIFIERS [244:8]
+    |       |   |--TYPE -> TYPE [244:8]
+    |       |   |   |--IDENT -> Runnable [244:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [244:16]
+    |       |   |       `--RBRACK -> ] [244:17]
+    |       |   |--IDENT -> runs [244:19]
+    |       |   `--ASSIGN -> = [244:24]
+    |       |       `--EXPR -> EXPR [244:26]
+    |       |           `--LITERAL_NEW -> new [244:26]
+    |       |               |--IDENT -> Runnable [244:30]
+    |       |               |--ARRAY_DECLARATOR -> [ [244:38]
+    |       |               |   `--RBRACK -> ] [244:39]
+    |       |               `--ARRAY_INIT -> { [244:41]
+    |       |                   |--EXPR -> EXPR [244:42]
+    |       |                   |   `--LITERAL_NEW -> new [244:42]
+    |       |                   |       |--IDENT -> Runnable [244:46]
+    |       |                   |       |--LPAREN -> ( [244:54]
+    |       |                   |       |--ELIST -> ELIST [244:55]
+    |       |                   |       |--RPAREN -> ) [244:55]
+    |       |                   |       `--OBJBLOCK -> OBJBLOCK [244:57]
+    |       |                   |           |--LCURLY -> { [244:57]
+    |       |                   |           |--METHOD_DEF -> METHOD_DEF [245:16]
+    |       |                   |           |   |--MODIFIERS -> MODIFIERS [245:16]
+    |       |                   |           |   |   `--LITERAL_PUBLIC -> public [245:16]
+    |       |                   |           |   |--TYPE -> TYPE [245:23]
+    |       |                   |           |   |   `--LITERAL_VOID -> void [245:23]
+    |       |                   |           |   |--IDENT -> run [245:28]
+    |       |                   |           |   |--LPAREN -> ( [245:31]
+    |       |                   |           |   |--PARAMETERS -> PARAMETERS [245:32]
+    |       |                   |           |   |--RPAREN -> ) [245:32]
+    |       |                   |           |   `--SLIST -> { [245:34]
+    |       |                   |           |       `--RCURLY -> } [246:16]
+    |       |                   |           `--RCURLY -> } [247:12]
+    |       |                   |--COMMA -> , [247:13]
+    |       |                   |--EXPR -> EXPR [248:12]
+    |       |                   |   `--LITERAL_NEW -> new [248:12]
+    |       |                   |       |--IDENT -> Runnable [248:16]
+    |       |                   |       |--LPAREN -> ( [248:24]
+    |       |                   |       |--ELIST -> ELIST [248:25]
+    |       |                   |       |--RPAREN -> ) [248:25]
+    |       |                   |       `--OBJBLOCK -> OBJBLOCK [248:27]
+    |       |                   |           |--LCURLY -> { [248:27]
+    |       |                   |           |--METHOD_DEF -> METHOD_DEF [249:16]
+    |       |                   |           |   |--MODIFIERS -> MODIFIERS [249:16]
+    |       |                   |           |   |   `--LITERAL_PUBLIC -> public [249:16]
+    |       |                   |           |   |--TYPE -> TYPE [249:23]
+    |       |                   |           |   |   `--LITERAL_VOID -> void [249:23]
+    |       |                   |           |   |--IDENT -> run [249:28]
+    |       |                   |           |   |--LPAREN -> ( [249:31]
+    |       |                   |           |   |--PARAMETERS -> PARAMETERS [249:32]
+    |       |                   |           |   |--RPAREN -> ) [249:32]
+    |       |                   |           |   `--SLIST -> { [249:34]
+    |       |                   |           |       `--RCURLY -> } [250:16]
+    |       |                   |           `--RCURLY -> } [251:12]
+    |       |                   `--RCURLY -> } [251:13]
+    |       |--SEMI -> ; [251:14]
+    |       |--EXPR -> EXPR [254:4]
+    |       |   `--METHOD_CALL -> ( [254:4]
+    |       |       |--DOT -> . [253:0]
+    |       |       |   |--INDEX_OP -> [ [252:12]
+    |       |       |   |   |--IDENT -> runs [252:8]
+    |       |       |   |   |--EXPR -> EXPR [252:13]
+    |       |       |   |   |   `--NUM_INT -> 0 [252:13]
+    |       |       |   |   `--RBRACK -> ] [252:14]
+    |       |       |   `--IDENT -> run [254:1]
+    |       |       |--ELIST -> ELIST [254:5]
+    |       |       `--RPAREN -> ) [254:5]
+    |       |--SEMI -> ; [255:0]
+    |       `--RCURLY -> } [256:4]
+    |--METHOD_DEF -> METHOD_DEF [258:4]
+    |   |--MODIFIERS -> MODIFIERS [258:4]
+    |   |   `--LITERAL_PUBLIC -> public [258:4]
+    |   |--TYPE -> TYPE [258:11]
+    |   |   `--LITERAL_VOID -> void [258:11]
+    |   |--IDENT -> testNullSemi [258:16]
+    |   |--LPAREN -> ( [258:28]
+    |   |--PARAMETERS -> PARAMETERS [258:29]
+    |   |--RPAREN -> ) [258:29]
+    |   `--SLIST -> { [258:31]
+    |       |--LITERAL_RETURN -> return [259:8]
+    |       |   `--SEMI -> ; [259:15]
+    |       `--RCURLY -> } [260:4]
+    |--METHOD_DEF -> METHOD_DEF [262:4]
+    |   |--MODIFIERS -> MODIFIERS [262:4]
+    |   |   `--LITERAL_PUBLIC -> public [262:4]
+    |   |--TYPE -> TYPE [262:11]
+    |   |   `--LITERAL_VOID -> void [262:11]
+    |   |--IDENT -> register [262:16]
+    |   |--LPAREN -> ( [262:24]
+    |   |--PARAMETERS -> PARAMETERS [262:25]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [262:25]
+    |   |       |--MODIFIERS -> MODIFIERS [262:25]
+    |   |       |--TYPE -> TYPE [262:25]
+    |   |       |   `--IDENT -> Object [262:25]
+    |   |       `--IDENT -> obj [262:32]
+    |   |--RPAREN -> ) [262:35]
+    |   `--SLIST -> { [262:37]
+    |       `--RCURLY -> } [262:39]
+    |--METHOD_DEF -> METHOD_DEF [264:4]
+    |   |--MODIFIERS -> MODIFIERS [264:4]
+    |   |   `--LITERAL_PUBLIC -> public [264:4]
+    |   |--TYPE -> TYPE [264:11]
+    |   |   `--LITERAL_VOID -> void [264:11]
+    |   |--IDENT -> doSomething [264:16]
+    |   |--LPAREN -> ( [264:27]
+    |   |--PARAMETERS -> PARAMETERS [264:28]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [264:28]
+    |   |       |--MODIFIERS -> MODIFIERS [264:28]
+    |   |       |--TYPE -> TYPE [264:28]
+    |   |       |   |--IDENT -> String [264:28]
+    |   |       |   `--ARRAY_DECLARATOR -> [ [264:39]
+    |   |       |       `--RBRACK -> ] [264:40]
+    |   |       `--IDENT -> args [264:35]
+    |   |--RPAREN -> ) [264:41]
+    |   `--SLIST -> { [264:43]
+    |       |--EXPR -> EXPR [265:16]
+    |       |   `--METHOD_CALL -> ( [265:16]
+    |       |       |--IDENT -> register [265:8]
+    |       |       |--ELIST -> ELIST [265:26]
+    |       |       |   `--EXPR -> EXPR [265:26]
+    |       |       |       `--DOT -> . [265:26]
+    |       |       |           |--LITERAL_BOOLEAN -> boolean [265:17]
+    |       |       |           |--ARRAY_DECLARATOR -> [ [265:24]
+    |       |       |           |   `--RBRACK -> ] [265:25]
+    |       |       |           `--LITERAL_CLASS -> class [265:27]
+    |       |       `--RPAREN -> ) [265:32]
+    |       |--SEMI -> ; [265:33]
+    |       |--EXPR -> EXPR [266:16]
+    |       |   `--METHOD_CALL -> ( [266:16]
+    |       |       |--IDENT -> register [266:8]
+    |       |       |--ELIST -> ELIST [266:18]
+    |       |       |   `--EXPR -> EXPR [266:18]
+    |       |       |       `--IDENT -> args [266:18]
+    |       |       `--RPAREN -> ) [266:23]
+    |       |--SEMI -> ; [266:24]
+    |       `--RCURLY -> } [267:4]
+    |--METHOD_DEF -> METHOD_DEF [269:4]
+    |   |--MODIFIERS -> MODIFIERS [269:4]
+    |   |   `--LITERAL_PUBLIC -> public [269:4]
+    |   |--TYPE -> TYPE [269:11]
+    |   |   `--LITERAL_VOID -> void [269:11]
+    |   |--IDENT -> parentheses [269:16]
+    |   |--LPAREN -> ( [269:27]
+    |   |--PARAMETERS -> PARAMETERS [269:28]
+    |   |--RPAREN -> ) [269:28]
+    |   `--SLIST -> { [269:30]
+    |       |--EXPR -> EXPR [271:0]
+    |       |   `--METHOD_CALL -> ( [271:0]
+    |       |       |--IDENT -> testNullSemi [270:8]
+    |       |       |--ELIST -> ELIST [272:0]
+    |       |       `--RPAREN -> ) [272:0]
+    |       |--SEMI -> ; [273:0]
+    |       `--RCURLY -> } [274:4]
+    |--METHOD_DEF -> METHOD_DEF [276:4]
+    |   |--MODIFIERS -> MODIFIERS [276:4]
+    |   |   |--LITERAL_PUBLIC -> public [276:4]
+    |   |   `--LITERAL_STATIC -> static [276:11]
+    |   |--TYPE -> TYPE [276:18]
+    |   |   `--LITERAL_VOID -> void [276:18]
+    |   |--IDENT -> testNoWhitespaceBeforeEllipses [276:23]
+    |   |--LPAREN -> ( [276:53]
+    |   |--PARAMETERS -> PARAMETERS [276:54]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [276:54]
+    |   |       |--MODIFIERS -> MODIFIERS [276:54]
+    |   |       |--TYPE -> TYPE [276:54]
+    |   |       |   `--IDENT -> String [276:54]
+    |   |       |--ELLIPSIS -> ... [276:61]
+    |   |       `--IDENT -> args [276:65]
+    |   |--RPAREN -> ) [276:69]
+    |   `--SLIST -> { [276:71]
+    |       `--RCURLY -> } [277:4]
+    |--METHOD_DEF -> METHOD_DEF [278:4]
+    |   |--MODIFIERS -> MODIFIERS [278:4]
+    |   |   `--LITERAL_PUBLIC -> public [278:4]
+    |   |--TYPE -> TYPE [278:11]
+    |   |   `--IDENT -> String [278:11]
+    |   |--IDENT -> test [278:18]
+    |   |--LPAREN -> ( [278:22]
+    |   |--PARAMETERS -> PARAMETERS [278:23]
+    |   |--RPAREN -> ) [278:23]
+    |   `--SLIST -> { [278:25]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [279:8]
+    |       |   |--MODIFIERS -> MODIFIERS [279:8]
+    |       |   |--TYPE -> TYPE [279:8]
+    |       |   |   `--LITERAL_INT -> int [279:8]
+    |       |   |--IDENT -> pc [279:12]
+    |       |   `--ASSIGN -> = [279:15]
+    |       |       `--EXPR -> EXPR [279:17]
+    |       |           `--NUM_INT -> 0 [279:17]
+    |       |--SEMI -> ; [279:18]
+    |       |--LITERAL_RETURN -> return [280:8]
+    |       |   |--EXPR -> EXPR [280:41]
+    |       |   |   `--METHOD_CALL -> ( [280:41]
+    |       |   |       |--DOT -> . [280:31]
+    |       |   |       |   |--LPAREN -> ( [280:15]
+    |       |   |       |   |--PLUS -> + [280:27]
+    |       |   |       |   |   |--LPAREN -> ( [280:16]
+    |       |   |       |   |   |--PLUS -> + [280:23]
+    |       |   |       |   |   |   |--NUM_INT -> 100000 [280:17]
+    |       |   |       |   |   |   `--IDENT -> pc [280:24]
+    |       |   |       |   |   |--RPAREN -> ) [280:26]
+    |       |   |       |   |   `--STRING_LITERAL -> "" [280:28]
+    |       |   |       |   |--RPAREN -> ) [280:30]
+    |       |   |       |   `--IDENT -> substring [280:32]
+    |       |   |       |--ELIST -> ELIST [280:42]
+    |       |   |       |   `--EXPR -> EXPR [280:42]
+    |       |   |       |       `--NUM_INT -> 1 [280:42]
+    |       |   |       `--RPAREN -> ) [280:43]
+    |       |   `--SEMI -> ; [280:44]
+    |       `--RCURLY -> } [281:4]
+    `--RCURLY -> } [282:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionMethodCall.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionMethodCall.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionMethodCall.java
@@ -0,0 +1,32 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+public class InputAntlr4AstRegressionMethodCall {
+    public static class IntData {
+        int[] xorData;
+
+        IntData(Object srcPixel, Object xorPixel) {
+            this.xorData = (int[]) srcPixel; // violation
+            this.xorData = (int[]) xorPixel; // violation
+        }
+
+        protected void xorPixel(Object pixData) {
+            int[] dstData = (int[]) pixData; // violation
+            for (int i = 0; i < dstData.length; i++) {
+                dstData[i] ^= xorData[i];
+            }
+        }
+
+        Object[] getXorData() {
+            return new Object[5];
+        }
+
+        void method6() {
+            if (getXorData().length == 5
+                    && this.getXorData()[1] != IntData.class // violation
+                    || this.getXorData()[5] != IntData.class) {
+                System.out.println(getXorData().length);
+            }
+        }
+
+    }
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionMethodCall.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionMethodCall.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionMethodCall.txt
@@ -0,0 +1,250 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+CLASS_DEF -> CLASS_DEF [3:0]
+|--MODIFIERS -> MODIFIERS [3:0]
+|   `--LITERAL_PUBLIC -> public [3:0]
+|--LITERAL_CLASS -> class [3:7]
+|--IDENT -> InputAntlr4AstRegressionMethodCall [3:13]
+`--OBJBLOCK -> OBJBLOCK [3:48]
+    |--LCURLY -> { [3:48]
+    |--CLASS_DEF -> CLASS_DEF [4:4]
+    |   |--MODIFIERS -> MODIFIERS [4:4]
+    |   |   |--LITERAL_PUBLIC -> public [4:4]
+    |   |   `--LITERAL_STATIC -> static [4:11]
+    |   |--LITERAL_CLASS -> class [4:18]
+    |   |--IDENT -> IntData [4:24]
+    |   `--OBJBLOCK -> OBJBLOCK [4:32]
+    |       |--LCURLY -> { [4:32]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [5:8]
+    |       |   |--MODIFIERS -> MODIFIERS [5:8]
+    |       |   |--TYPE -> TYPE [5:8]
+    |       |   |   |--LITERAL_INT -> int [5:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [5:11]
+    |       |   |       `--RBRACK -> ] [5:12]
+    |       |   |--IDENT -> xorData [5:14]
+    |       |   `--SEMI -> ; [5:21]
+    |       |--CTOR_DEF -> CTOR_DEF [7:8]
+    |       |   |--MODIFIERS -> MODIFIERS [7:8]
+    |       |   |--IDENT -> IntData [7:8]
+    |       |   |--LPAREN -> ( [7:15]
+    |       |   |--PARAMETERS -> PARAMETERS [7:16]
+    |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [7:16]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [7:16]
+    |       |   |   |   |--TYPE -> TYPE [7:16]
+    |       |   |   |   |   `--IDENT -> Object [7:16]
+    |       |   |   |   `--IDENT -> srcPixel [7:23]
+    |       |   |   |--COMMA -> , [7:31]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [7:33]
+    |       |   |       |--MODIFIERS -> MODIFIERS [7:33]
+    |       |   |       |--TYPE -> TYPE [7:33]
+    |       |   |       |   `--IDENT -> Object [7:33]
+    |       |   |       `--IDENT -> xorPixel [7:40]
+    |       |   |--RPAREN -> ) [7:48]
+    |       |   `--SLIST -> { [7:50]
+    |       |       |--EXPR -> EXPR [8:25]
+    |       |       |   `--ASSIGN -> = [8:25]
+    |       |       |       |--DOT -> . [8:16]
+    |       |       |       |   |--LITERAL_THIS -> this [8:12]
+    |       |       |       |   `--IDENT -> xorData [8:17]
+    |       |       |       `--TYPECAST -> ( [8:27]
+    |       |       |           |--TYPE -> TYPE [8:28]
+    |       |       |           |   |--LITERAL_INT -> int [8:28]
+    |       |       |           |   `--ARRAY_DECLARATOR -> [ [8:31]
+    |       |       |           |       `--RBRACK -> ] [8:32]
+    |       |       |           |--RPAREN -> ) [8:33]
+    |       |       |           `--IDENT -> srcPixel [8:35]
+    |       |       |--SEMI -> ; [8:43]
+    |       |       |--EXPR -> EXPR [9:25]
+    |       |       |   `--ASSIGN -> = [9:25]
+    |       |       |       |--DOT -> . [9:16]
+    |       |       |       |   |--LITERAL_THIS -> this [9:12]
+    |       |       |       |   `--IDENT -> xorData [9:17]
+    |       |       |       `--TYPECAST -> ( [9:27]
+    |       |       |           |--TYPE -> TYPE [9:28]
+    |       |       |           |   |--LITERAL_INT -> int [9:28]
+    |       |       |           |   `--ARRAY_DECLARATOR -> [ [9:31]
+    |       |       |           |       `--RBRACK -> ] [9:32]
+    |       |       |           |--RPAREN -> ) [9:33]
+    |       |       |           `--IDENT -> xorPixel [9:35]
+    |       |       |--SEMI -> ; [9:43]
+    |       |       `--RCURLY -> } [10:8]
+    |       |--METHOD_DEF -> METHOD_DEF [12:8]
+    |       |   |--MODIFIERS -> MODIFIERS [12:8]
+    |       |   |   `--LITERAL_PROTECTED -> protected [12:8]
+    |       |   |--TYPE -> TYPE [12:18]
+    |       |   |   `--LITERAL_VOID -> void [12:18]
+    |       |   |--IDENT -> xorPixel [12:23]
+    |       |   |--LPAREN -> ( [12:31]
+    |       |   |--PARAMETERS -> PARAMETERS [12:32]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [12:32]
+    |       |   |       |--MODIFIERS -> MODIFIERS [12:32]
+    |       |   |       |--TYPE -> TYPE [12:32]
+    |       |   |       |   `--IDENT -> Object [12:32]
+    |       |   |       `--IDENT -> pixData [12:39]
+    |       |   |--RPAREN -> ) [12:46]
+    |       |   `--SLIST -> { [12:48]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [13:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [13:12]
+    |       |       |   |--TYPE -> TYPE [13:12]
+    |       |       |   |   |--LITERAL_INT -> int [13:12]
+    |       |       |   |   `--ARRAY_DECLARATOR -> [ [13:15]
+    |       |       |   |       `--RBRACK -> ] [13:16]
+    |       |       |   |--IDENT -> dstData [13:18]
+    |       |       |   `--ASSIGN -> = [13:26]
+    |       |       |       `--EXPR -> EXPR [13:28]
+    |       |       |           `--TYPECAST -> ( [13:28]
+    |       |       |               |--TYPE -> TYPE [13:29]
+    |       |       |               |   |--LITERAL_INT -> int [13:29]
+    |       |       |               |   `--ARRAY_DECLARATOR -> [ [13:32]
+    |       |       |               |       `--RBRACK -> ] [13:33]
+    |       |       |               |--RPAREN -> ) [13:34]
+    |       |       |               `--IDENT -> pixData [13:36]
+    |       |       |--SEMI -> ; [13:43]
+    |       |       |--LITERAL_FOR -> for [14:12]
+    |       |       |   |--LPAREN -> ( [14:16]
+    |       |       |   |--FOR_INIT -> FOR_INIT [14:17]
+    |       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [14:17]
+    |       |       |   |       |--MODIFIERS -> MODIFIERS [14:17]
+    |       |       |   |       |--TYPE -> TYPE [14:17]
+    |       |       |   |       |   `--LITERAL_INT -> int [14:17]
+    |       |       |   |       |--IDENT -> i [14:21]
+    |       |       |   |       `--ASSIGN -> = [14:23]
+    |       |       |   |           `--EXPR -> EXPR [14:25]
+    |       |       |   |               `--NUM_INT -> 0 [14:25]
+    |       |       |   |--SEMI -> ; [14:26]
+    |       |       |   |--FOR_CONDITION -> FOR_CONDITION [14:30]
+    |       |       |   |   `--EXPR -> EXPR [14:30]
+    |       |       |   |       `--LT -> < [14:30]
+    |       |       |   |           |--IDENT -> i [14:28]
+    |       |       |   |           `--DOT -> . [14:39]
+    |       |       |   |               |--IDENT -> dstData [14:32]
+    |       |       |   |               `--IDENT -> length [14:40]
+    |       |       |   |--SEMI -> ; [14:46]
+    |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [14:49]
+    |       |       |   |   `--ELIST -> ELIST [14:49]
+    |       |       |   |       `--EXPR -> EXPR [14:49]
+    |       |       |   |           `--POST_INC -> ++ [14:49]
+    |       |       |   |               `--IDENT -> i [14:48]
+    |       |       |   |--RPAREN -> ) [14:51]
+    |       |       |   `--SLIST -> { [14:53]
+    |       |       |       |--EXPR -> EXPR [15:27]
+    |       |       |       |   `--BXOR_ASSIGN -> ^= [15:27]
+    |       |       |       |       |--INDEX_OP -> [ [15:23]
+    |       |       |       |       |   |--IDENT -> dstData [15:16]
+    |       |       |       |       |   |--EXPR -> EXPR [15:24]
+    |       |       |       |       |   |   `--IDENT -> i [15:24]
+    |       |       |       |       |   `--RBRACK -> ] [15:25]
+    |       |       |       |       `--INDEX_OP -> [ [15:37]
+    |       |       |       |           |--IDENT -> xorData [15:30]
+    |       |       |       |           |--EXPR -> EXPR [15:38]
+    |       |       |       |           |   `--IDENT -> i [15:38]
+    |       |       |       |           `--RBRACK -> ] [15:39]
+    |       |       |       |--SEMI -> ; [15:40]
+    |       |       |       `--RCURLY -> } [16:12]
+    |       |       `--RCURLY -> } [17:8]
+    |       |--METHOD_DEF -> METHOD_DEF [19:8]
+    |       |   |--MODIFIERS -> MODIFIERS [19:8]
+    |       |   |--TYPE -> TYPE [19:8]
+    |       |   |   |--IDENT -> Object [19:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [19:14]
+    |       |   |       `--RBRACK -> ] [19:15]
+    |       |   |--IDENT -> getXorData [19:17]
+    |       |   |--LPAREN -> ( [19:27]
+    |       |   |--PARAMETERS -> PARAMETERS [19:28]
+    |       |   |--RPAREN -> ) [19:28]
+    |       |   `--SLIST -> { [19:30]
+    |       |       |--LITERAL_RETURN -> return [20:12]
+    |       |       |   |--EXPR -> EXPR [20:19]
+    |       |       |   |   `--LITERAL_NEW -> new [20:19]
+    |       |       |   |       |--IDENT -> Object [20:23]
+    |       |       |   |       `--ARRAY_DECLARATOR -> [ [20:29]
+    |       |       |   |           |--EXPR -> EXPR [20:30]
+    |       |       |   |           |   `--NUM_INT -> 5 [20:30]
+    |       |       |   |           `--RBRACK -> ] [20:31]
+    |       |       |   `--SEMI -> ; [20:32]
+    |       |       `--RCURLY -> } [21:8]
+    |       |--METHOD_DEF -> METHOD_DEF [23:8]
+    |       |   |--MODIFIERS -> MODIFIERS [23:8]
+    |       |   |--TYPE -> TYPE [23:8]
+    |       |   |   `--LITERAL_VOID -> void [23:8]
+    |       |   |--IDENT -> method6 [23:13]
+    |       |   |--LPAREN -> ( [23:20]
+    |       |   |--PARAMETERS -> PARAMETERS [23:21]
+    |       |   |--RPAREN -> ) [23:21]
+    |       |   `--SLIST -> { [23:23]
+    |       |       |--LITERAL_IF -> if [24:12]
+    |       |       |   |--LPAREN -> ( [24:15]
+    |       |       |   |--EXPR -> EXPR [26:20]
+    |       |       |   |   `--LOR -> || [26:20]
+    |       |       |   |       |--LAND -> && [25:20]
+    |       |       |   |       |   |--EQUAL -> == [24:36]
+    |       |       |   |       |   |   |--DOT -> . [24:28]
+    |       |       |   |       |   |   |   |--METHOD_CALL -> ( [24:26]
+    |       |       |   |       |   |   |   |   |--IDENT -> getXorData [24:16]
+    |       |       |   |       |   |   |   |   |--ELIST -> ELIST [24:27]
+    |       |       |   |       |   |   |   |   `--RPAREN -> ) [24:27]
+    |       |       |   |       |   |   |   `--IDENT -> length [24:29]
+    |       |       |   |       |   |   `--NUM_INT -> 5 [24:39]
+    |       |       |   |       |   `--NOT_EQUAL -> != [25:44]
+    |       |       |   |       |       |--INDEX_OP -> [ [25:40]
+    |       |       |   |       |       |   |--METHOD_CALL -> ( [25:38]
+    |       |       |   |       |       |   |   |--DOT -> . [25:27]
+    |       |       |   |       |       |   |   |   |--LITERAL_THIS -> this [25:23]
+    |       |       |   |       |       |   |   |   `--IDENT -> getXorData [25:28]
+    |       |       |   |       |       |   |   |--ELIST -> ELIST [25:39]
+    |       |       |   |       |       |   |   `--RPAREN -> ) [25:39]
+    |       |       |   |       |       |   |--EXPR -> EXPR [25:41]
+    |       |       |   |       |       |   |   `--NUM_INT -> 1 [25:41]
+    |       |       |   |       |       |   `--RBRACK -> ] [25:42]
+    |       |       |   |       |       `--DOT -> . [25:54]
+    |       |       |   |       |           |--IDENT -> IntData [25:47]
+    |       |       |   |       |           `--LITERAL_CLASS -> class [25:55]
+    |       |       |   |       `--NOT_EQUAL -> != [26:44]
+    |       |       |   |           |--INDEX_OP -> [ [26:40]
+    |       |       |   |           |   |--METHOD_CALL -> ( [26:38]
+    |       |       |   |           |   |   |--DOT -> . [26:27]
+    |       |       |   |           |   |   |   |--LITERAL_THIS -> this [26:23]
+    |       |       |   |           |   |   |   `--IDENT -> getXorData [26:28]
+    |       |       |   |           |   |   |--ELIST -> ELIST [26:39]
+    |       |       |   |           |   |   `--RPAREN -> ) [26:39]
+    |       |       |   |           |   |--EXPR -> EXPR [26:41]
+    |       |       |   |           |   |   `--NUM_INT -> 5 [26:41]
+    |       |       |   |           |   `--RBRACK -> ] [26:42]
+    |       |       |   |           `--DOT -> . [26:54]
+    |       |       |   |               |--IDENT -> IntData [26:47]
+    |       |       |   |               `--LITERAL_CLASS -> class [26:55]
+    |       |       |   |--RPAREN -> ) [26:60]
+    |       |       |   `--SLIST -> { [26:62]
+    |       |       |       |--EXPR -> EXPR [27:34]
+    |       |       |       |   `--METHOD_CALL -> ( [27:34]
+    |       |       |       |       |--DOT -> . [27:26]
+    |       |       |       |       |   |--DOT -> . [27:22]
+    |       |       |       |       |   |   |--IDENT -> System [27:16]
+    |       |       |       |       |   |   `--IDENT -> out [27:23]
+    |       |       |       |       |   `--IDENT -> println [27:27]
+    |       |       |       |       |--ELIST -> ELIST [27:47]
+    |       |       |       |       |   `--EXPR -> EXPR [27:47]
+    |       |       |       |       |       `--DOT -> . [27:47]
+    |       |       |       |       |           |--METHOD_CALL -> ( [27:45]
+    |       |       |       |       |           |   |--IDENT -> getXorData [27:35]
+    |       |       |       |       |           |   |--ELIST -> ELIST [27:46]
+    |       |       |       |       |           |   `--RPAREN -> ) [27:46]
+    |       |       |       |       |           `--IDENT -> length [27:48]
+    |       |       |       |       `--RPAREN -> ) [27:54]
+    |       |       |       |--SEMI -> ; [27:55]
+    |       |       |       `--RCURLY -> } [28:12]
+    |       |       `--RCURLY -> } [29:8]
+    |       `--RCURLY -> } [31:4]
+    `--RCURLY -> } [32:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionMethodRefs.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionMethodRefs.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionMethodRefs.java
@@ -0,0 +1,52 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+import java.util.List;
+import java.util.function.Supplier;
+
+public class InputAntlr4AstRegressionMethodRefs {
+   interface LambdaInt {
+        <S, T> void m(S p1, T p2);
+    }
+
+    interface MyFunctionalInterface {
+        void invokeMethodReference();
+    }
+
+    static class LambdaImpl implements LambdaInt {
+        <S, T> LambdaImpl(S p1, T p2) {
+        }
+
+        public <S, T> void m(S p1, T p2) {
+        }
+    }
+
+    public void m() {
+    }
+
+    public void main(String[] args) {
+        MyFunctionalInterface fi =
+                new InputAntlr4AstRegressionMethodRefs()::<Integer, String, Long> m;
+        LambdaInt li = LambdaImpl::<@TA Object, @TB Object> new;
+        Supplier s = Bar1::<String> m;
+        li = li::<@TA Object, @TB Object> m;
+        s = Bar1::<List<String>> m;
+        s = Bar1::<List<List<?>>> m;
+    }
+}
+
+class Bar1<T> {
+    static Object m() {
+        return null;
+    }
+}
+
+@Target({ ElementType.TYPE_USE, ElementType.TYPE_PARAMETER })
+@interface TA {
+}
+
+@Target({ ElementType.TYPE_USE, ElementType.TYPE_PARAMETER })
+@interface TB {
+}
+
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionMethodRefs.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionMethodRefs.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionMethodRefs.txt
@@ -0,0 +1,409 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+IMPORT -> import [3:0]
+|--DOT -> . [3:27]
+|   |--DOT -> . [3:16]
+|   |   |--DOT -> . [3:11]
+|   |   |   |--IDENT -> java [3:7]
+|   |   |   `--IDENT -> lang [3:12]
+|   |   `--IDENT -> annotation [3:17]
+|   `--IDENT -> ElementType [3:28]
+`--SEMI -> ; [3:39]
+IMPORT -> import [4:0]
+|--DOT -> . [4:27]
+|   |--DOT -> . [4:16]
+|   |   |--DOT -> . [4:11]
+|   |   |   |--IDENT -> java [4:7]
+|   |   |   `--IDENT -> lang [4:12]
+|   |   `--IDENT -> annotation [4:17]
+|   `--IDENT -> Target [4:28]
+`--SEMI -> ; [4:34]
+IMPORT -> import [5:0]
+|--DOT -> . [5:16]
+|   |--DOT -> . [5:11]
+|   |   |--IDENT -> java [5:7]
+|   |   `--IDENT -> util [5:12]
+|   `--IDENT -> List [5:17]
+`--SEMI -> ; [5:21]
+IMPORT -> import [6:0]
+|--DOT -> . [6:25]
+|   |--DOT -> . [6:16]
+|   |   |--DOT -> . [6:11]
+|   |   |   |--IDENT -> java [6:7]
+|   |   |   `--IDENT -> util [6:12]
+|   |   `--IDENT -> function [6:17]
+|   `--IDENT -> Supplier [6:26]
+`--SEMI -> ; [6:34]
+CLASS_DEF -> CLASS_DEF [8:0]
+|--MODIFIERS -> MODIFIERS [8:0]
+|   `--LITERAL_PUBLIC -> public [8:0]
+|--LITERAL_CLASS -> class [8:7]
+|--IDENT -> InputAntlr4AstRegressionMethodRefs [8:13]
+`--OBJBLOCK -> OBJBLOCK [8:48]
+    |--LCURLY -> { [8:48]
+    |--INTERFACE_DEF -> INTERFACE_DEF [9:3]
+    |   |--MODIFIERS -> MODIFIERS [9:3]
+    |   |--LITERAL_INTERFACE -> interface [9:3]
+    |   |--IDENT -> LambdaInt [9:13]
+    |   `--OBJBLOCK -> OBJBLOCK [9:23]
+    |       |--LCURLY -> { [9:23]
+    |       |--METHOD_DEF -> METHOD_DEF [10:8]
+    |       |   |--MODIFIERS -> MODIFIERS [10:8]
+    |       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [10:8]
+    |       |   |   |--GENERIC_START -> < [10:8]
+    |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [10:9]
+    |       |   |   |   `--IDENT -> S [10:9]
+    |       |   |   |--COMMA -> , [10:10]
+    |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [10:12]
+    |       |   |   |   `--IDENT -> T [10:12]
+    |       |   |   `--GENERIC_END -> > [10:13]
+    |       |   |--TYPE -> TYPE [10:15]
+    |       |   |   `--LITERAL_VOID -> void [10:15]
+    |       |   |--IDENT -> m [10:20]
+    |       |   |--LPAREN -> ( [10:21]
+    |       |   |--PARAMETERS -> PARAMETERS [10:22]
+    |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [10:22]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [10:22]
+    |       |   |   |   |--TYPE -> TYPE [10:22]
+    |       |   |   |   |   `--IDENT -> S [10:22]
+    |       |   |   |   `--IDENT -> p1 [10:24]
+    |       |   |   |--COMMA -> , [10:26]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [10:28]
+    |       |   |       |--MODIFIERS -> MODIFIERS [10:28]
+    |       |   |       |--TYPE -> TYPE [10:28]
+    |       |   |       |   `--IDENT -> T [10:28]
+    |       |   |       `--IDENT -> p2 [10:30]
+    |       |   |--RPAREN -> ) [10:32]
+    |       |   `--SEMI -> ; [10:33]
+    |       `--RCURLY -> } [11:4]
+    |--INTERFACE_DEF -> INTERFACE_DEF [13:4]
+    |   |--MODIFIERS -> MODIFIERS [13:4]
+    |   |--LITERAL_INTERFACE -> interface [13:4]
+    |   |--IDENT -> MyFunctionalInterface [13:14]
+    |   `--OBJBLOCK -> OBJBLOCK [13:36]
+    |       |--LCURLY -> { [13:36]
+    |       |--METHOD_DEF -> METHOD_DEF [14:8]
+    |       |   |--MODIFIERS -> MODIFIERS [14:8]
+    |       |   |--TYPE -> TYPE [14:8]
+    |       |   |   `--LITERAL_VOID -> void [14:8]
+    |       |   |--IDENT -> invokeMethodReference [14:13]
+    |       |   |--LPAREN -> ( [14:34]
+    |       |   |--PARAMETERS -> PARAMETERS [14:35]
+    |       |   |--RPAREN -> ) [14:35]
+    |       |   `--SEMI -> ; [14:36]
+    |       `--RCURLY -> } [15:4]
+    |--CLASS_DEF -> CLASS_DEF [17:4]
+    |   |--MODIFIERS -> MODIFIERS [17:4]
+    |   |   `--LITERAL_STATIC -> static [17:4]
+    |   |--LITERAL_CLASS -> class [17:11]
+    |   |--IDENT -> LambdaImpl [17:17]
+    |   |--IMPLEMENTS_CLAUSE -> implements [17:28]
+    |   |   `--IDENT -> LambdaInt [17:39]
+    |   `--OBJBLOCK -> OBJBLOCK [17:49]
+    |       |--LCURLY -> { [17:49]
+    |       |--CTOR_DEF -> CTOR_DEF [18:8]
+    |       |   |--MODIFIERS -> MODIFIERS [18:8]
+    |       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [18:8]
+    |       |   |   |--GENERIC_START -> < [18:8]
+    |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [18:9]
+    |       |   |   |   `--IDENT -> S [18:9]
+    |       |   |   |--COMMA -> , [18:10]
+    |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [18:12]
+    |       |   |   |   `--IDENT -> T [18:12]
+    |       |   |   `--GENERIC_END -> > [18:13]
+    |       |   |--IDENT -> LambdaImpl [18:15]
+    |       |   |--LPAREN -> ( [18:25]
+    |       |   |--PARAMETERS -> PARAMETERS [18:26]
+    |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [18:26]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [18:26]
+    |       |   |   |   |--TYPE -> TYPE [18:26]
+    |       |   |   |   |   `--IDENT -> S [18:26]
+    |       |   |   |   `--IDENT -> p1 [18:28]
+    |       |   |   |--COMMA -> , [18:30]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [18:32]
+    |       |   |       |--MODIFIERS -> MODIFIERS [18:32]
+    |       |   |       |--TYPE -> TYPE [18:32]
+    |       |   |       |   `--IDENT -> T [18:32]
+    |       |   |       `--IDENT -> p2 [18:34]
+    |       |   |--RPAREN -> ) [18:36]
+    |       |   `--SLIST -> { [18:38]
+    |       |       `--RCURLY -> } [19:8]
+    |       |--METHOD_DEF -> METHOD_DEF [21:8]
+    |       |   |--MODIFIERS -> MODIFIERS [21:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [21:8]
+    |       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [21:15]
+    |       |   |   |--GENERIC_START -> < [21:15]
+    |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [21:16]
+    |       |   |   |   `--IDENT -> S [21:16]
+    |       |   |   |--COMMA -> , [21:17]
+    |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [21:19]
+    |       |   |   |   `--IDENT -> T [21:19]
+    |       |   |   `--GENERIC_END -> > [21:20]
+    |       |   |--TYPE -> TYPE [21:22]
+    |       |   |   `--LITERAL_VOID -> void [21:22]
+    |       |   |--IDENT -> m [21:27]
+    |       |   |--LPAREN -> ( [21:28]
+    |       |   |--PARAMETERS -> PARAMETERS [21:29]
+    |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [21:29]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [21:29]
+    |       |   |   |   |--TYPE -> TYPE [21:29]
+    |       |   |   |   |   `--IDENT -> S [21:29]
+    |       |   |   |   `--IDENT -> p1 [21:31]
+    |       |   |   |--COMMA -> , [21:33]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [21:35]
+    |       |   |       |--MODIFIERS -> MODIFIERS [21:35]
+    |       |   |       |--TYPE -> TYPE [21:35]
+    |       |   |       |   `--IDENT -> T [21:35]
+    |       |   |       `--IDENT -> p2 [21:37]
+    |       |   |--RPAREN -> ) [21:39]
+    |       |   `--SLIST -> { [21:41]
+    |       |       `--RCURLY -> } [22:8]
+    |       `--RCURLY -> } [23:4]
+    |--METHOD_DEF -> METHOD_DEF [25:4]
+    |   |--MODIFIERS -> MODIFIERS [25:4]
+    |   |   `--LITERAL_PUBLIC -> public [25:4]
+    |   |--TYPE -> TYPE [25:11]
+    |   |   `--LITERAL_VOID -> void [25:11]
+    |   |--IDENT -> m [25:16]
+    |   |--LPAREN -> ( [25:17]
+    |   |--PARAMETERS -> PARAMETERS [25:18]
+    |   |--RPAREN -> ) [25:18]
+    |   `--SLIST -> { [25:20]
+    |       `--RCURLY -> } [26:4]
+    |--METHOD_DEF -> METHOD_DEF [28:4]
+    |   |--MODIFIERS -> MODIFIERS [28:4]
+    |   |   `--LITERAL_PUBLIC -> public [28:4]
+    |   |--TYPE -> TYPE [28:11]
+    |   |   `--LITERAL_VOID -> void [28:11]
+    |   |--IDENT -> main [28:16]
+    |   |--LPAREN -> ( [28:20]
+    |   |--PARAMETERS -> PARAMETERS [28:21]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [28:21]
+    |   |       |--MODIFIERS -> MODIFIERS [28:21]
+    |   |       |--TYPE -> TYPE [28:21]
+    |   |       |   |--IDENT -> String [28:21]
+    |   |       |   `--ARRAY_DECLARATOR -> [ [28:27]
+    |   |       |       `--RBRACK -> ] [28:28]
+    |   |       `--IDENT -> args [28:30]
+    |   |--RPAREN -> ) [28:34]
+    |   `--SLIST -> { [28:36]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [29:8]
+    |       |   |--MODIFIERS -> MODIFIERS [29:8]
+    |       |   |--TYPE -> TYPE [29:8]
+    |       |   |   `--IDENT -> MyFunctionalInterface [29:8]
+    |       |   |--IDENT -> fi [29:30]
+    |       |   `--ASSIGN -> = [29:33]
+    |       |       `--EXPR -> EXPR [30:56]
+    |       |           `--METHOD_REF -> :: [30:56]
+    |       |               |--LITERAL_NEW -> new [30:16]
+    |       |               |   |--IDENT -> InputAntlr4AstRegressionMethodRefs [30:20]
+    |       |               |   |--LPAREN -> ( [30:54]
+    |       |               |   |--ELIST -> ELIST [30:55]
+    |       |               |   `--RPAREN -> ) [30:55]
+    |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [30:58]
+    |       |               |   |--GENERIC_START -> < [30:58]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [30:59]
+    |       |               |   |   `--IDENT -> Integer [30:59]
+    |       |               |   |--COMMA -> , [30:66]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [30:68]
+    |       |               |   |   `--IDENT -> String [30:68]
+    |       |               |   |--COMMA -> , [30:74]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [30:76]
+    |       |               |   |   `--IDENT -> Long [30:76]
+    |       |               |   `--GENERIC_END -> > [30:80]
+    |       |               `--IDENT -> m [30:82]
+    |       |--SEMI -> ; [30:83]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [31:8]
+    |       |   |--MODIFIERS -> MODIFIERS [31:8]
+    |       |   |--TYPE -> TYPE [31:8]
+    |       |   |   `--IDENT -> LambdaInt [31:8]
+    |       |   |--IDENT -> li [31:18]
+    |       |   `--ASSIGN -> = [31:21]
+    |       |       `--EXPR -> EXPR [31:33]
+    |       |           `--METHOD_REF -> :: [31:33]
+    |       |               |--IDENT -> LambdaImpl [31:23]
+    |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:35]
+    |       |               |   |--GENERIC_START -> < [31:35]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:36]
+    |       |               |   |   |--ANNOTATIONS -> ANNOTATIONS [31:36]
+    |       |               |   |   |   `--ANNOTATION -> ANNOTATION [31:36]
+    |       |               |   |   |       |--AT -> @ [31:36]
+    |       |               |   |   |       `--IDENT -> TA [31:37]
+    |       |               |   |   `--IDENT -> Object [31:40]
+    |       |               |   |--COMMA -> , [31:46]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:48]
+    |       |               |   |   |--ANNOTATIONS -> ANNOTATIONS [31:48]
+    |       |               |   |   |   `--ANNOTATION -> ANNOTATION [31:48]
+    |       |               |   |   |       |--AT -> @ [31:48]
+    |       |               |   |   |       `--IDENT -> TB [31:49]
+    |       |               |   |   `--IDENT -> Object [31:52]
+    |       |               |   `--GENERIC_END -> > [31:58]
+    |       |               `--LITERAL_NEW -> new [31:60]
+    |       |--SEMI -> ; [31:63]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [32:8]
+    |       |   |--MODIFIERS -> MODIFIERS [32:8]
+    |       |   |--TYPE -> TYPE [32:8]
+    |       |   |   `--IDENT -> Supplier [32:8]
+    |       |   |--IDENT -> s [32:17]
+    |       |   `--ASSIGN -> = [32:19]
+    |       |       `--EXPR -> EXPR [32:25]
+    |       |           `--METHOD_REF -> :: [32:25]
+    |       |               |--IDENT -> Bar1 [32:21]
+    |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [32:27]
+    |       |               |   |--GENERIC_START -> < [32:27]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [32:28]
+    |       |               |   |   `--IDENT -> String [32:28]
+    |       |               |   `--GENERIC_END -> > [32:34]
+    |       |               `--IDENT -> m [32:36]
+    |       |--SEMI -> ; [32:37]
+    |       |--EXPR -> EXPR [33:11]
+    |       |   `--ASSIGN -> = [33:11]
+    |       |       |--IDENT -> li [33:8]
+    |       |       `--METHOD_REF -> :: [33:15]
+    |       |           |--IDENT -> li [33:13]
+    |       |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [33:17]
+    |       |           |   |--GENERIC_START -> < [33:17]
+    |       |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [33:18]
+    |       |           |   |   |--ANNOTATIONS -> ANNOTATIONS [33:18]
+    |       |           |   |   |   `--ANNOTATION -> ANNOTATION [33:18]
+    |       |           |   |   |       |--AT -> @ [33:18]
+    |       |           |   |   |       `--IDENT -> TA [33:19]
+    |       |           |   |   `--IDENT -> Object [33:22]
+    |       |           |   |--COMMA -> , [33:28]
+    |       |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [33:30]
+    |       |           |   |   |--ANNOTATIONS -> ANNOTATIONS [33:30]
+    |       |           |   |   |   `--ANNOTATION -> ANNOTATION [33:30]
+    |       |           |   |   |       |--AT -> @ [33:30]
+    |       |           |   |   |       `--IDENT -> TB [33:31]
+    |       |           |   |   `--IDENT -> Object [33:34]
+    |       |           |   `--GENERIC_END -> > [33:40]
+    |       |           `--IDENT -> m [33:42]
+    |       |--SEMI -> ; [33:43]
+    |       |--EXPR -> EXPR [34:10]
+    |       |   `--ASSIGN -> = [34:10]
+    |       |       |--IDENT -> s [34:8]
+    |       |       `--METHOD_REF -> :: [34:16]
+    |       |           |--IDENT -> Bar1 [34:12]
+    |       |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [34:18]
+    |       |           |   |--GENERIC_START -> < [34:18]
+    |       |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [34:19]
+    |       |           |   |   |--IDENT -> List [34:19]
+    |       |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [34:23]
+    |       |           |   |       |--GENERIC_START -> < [34:23]
+    |       |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [34:24]
+    |       |           |   |       |   `--IDENT -> String [34:24]
+    |       |           |   |       `--GENERIC_END -> > [34:30]
+    |       |           |   `--GENERIC_END -> > [34:31]
+    |       |           `--IDENT -> m [34:33]
+    |       |--SEMI -> ; [34:34]
+    |       |--EXPR -> EXPR [35:10]
+    |       |   `--ASSIGN -> = [35:10]
+    |       |       |--IDENT -> s [35:8]
+    |       |       `--METHOD_REF -> :: [35:16]
+    |       |           |--IDENT -> Bar1 [35:12]
+    |       |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [35:18]
+    |       |           |   |--GENERIC_START -> < [35:18]
+    |       |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [35:19]
+    |       |           |   |   |--IDENT -> List [35:19]
+    |       |           |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [35:23]
+    |       |           |   |       |--GENERIC_START -> < [35:23]
+    |       |           |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [35:24]
+    |       |           |   |       |   |--IDENT -> List [35:24]
+    |       |           |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [35:28]
+    |       |           |   |       |       |--GENERIC_START -> < [35:28]
+    |       |           |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [35:29]
+    |       |           |   |       |       |   `--WILDCARD_TYPE -> ? [35:29]
+    |       |           |   |       |       `--GENERIC_END -> > [35:30]
+    |       |           |   |       `--GENERIC_END -> > [35:31]
+    |       |           |   `--GENERIC_END -> > [35:32]
+    |       |           `--IDENT -> m [35:34]
+    |       |--SEMI -> ; [35:35]
+    |       `--RCURLY -> } [36:4]
+    `--RCURLY -> } [37:0]
+CLASS_DEF -> CLASS_DEF [39:0]
+|--MODIFIERS -> MODIFIERS [39:0]
+|--LITERAL_CLASS -> class [39:0]
+|--IDENT -> Bar1 [39:6]
+|--TYPE_PARAMETERS -> TYPE_PARAMETERS [39:10]
+|   |--GENERIC_START -> < [39:10]
+|   |--TYPE_PARAMETER -> TYPE_PARAMETER [39:11]
+|   |   `--IDENT -> T [39:11]
+|   `--GENERIC_END -> > [39:12]
+`--OBJBLOCK -> OBJBLOCK [39:14]
+    |--LCURLY -> { [39:14]
+    |--METHOD_DEF -> METHOD_DEF [40:4]
+    |   |--MODIFIERS -> MODIFIERS [40:4]
+    |   |   `--LITERAL_STATIC -> static [40:4]
+    |   |--TYPE -> TYPE [40:11]
+    |   |   `--IDENT -> Object [40:11]
+    |   |--IDENT -> m [40:18]
+    |   |--LPAREN -> ( [40:19]
+    |   |--PARAMETERS -> PARAMETERS [40:20]
+    |   |--RPAREN -> ) [40:20]
+    |   `--SLIST -> { [40:22]
+    |       |--LITERAL_RETURN -> return [41:8]
+    |       |   |--EXPR -> EXPR [41:15]
+    |       |   |   `--LITERAL_NULL -> null [41:15]
+    |       |   `--SEMI -> ; [41:19]
+    |       `--RCURLY -> } [42:4]
+    `--RCURLY -> } [43:0]
+ANNOTATION_DEF -> ANNOTATION_DEF [45:0]
+|--MODIFIERS -> MODIFIERS [45:0]
+|   `--ANNOTATION -> ANNOTATION [45:0]
+|       |--AT -> @ [45:0]
+|       |--IDENT -> Target [45:1]
+|       |--LPAREN -> ( [45:7]
+|       |--ANNOTATION_ARRAY_INIT -> { [45:8]
+|       |   |--EXPR -> EXPR [45:21]
+|       |   |   `--DOT -> . [45:21]
+|       |   |       |--IDENT -> ElementType [45:10]
+|       |   |       `--IDENT -> TYPE_USE [45:22]
+|       |   |--COMMA -> , [45:30]
+|       |   |--EXPR -> EXPR [45:43]
+|       |   |   `--DOT -> . [45:43]
+|       |   |       |--IDENT -> ElementType [45:32]
+|       |   |       `--IDENT -> TYPE_PARAMETER [45:44]
+|       |   `--RCURLY -> } [45:59]
+|       `--RPAREN -> ) [45:60]
+|--AT -> @ [46:0]
+|--LITERAL_INTERFACE -> interface [46:1]
+|--IDENT -> TA [46:11]
+`--OBJBLOCK -> OBJBLOCK [46:14]
+    |--LCURLY -> { [46:14]
+    `--RCURLY -> } [47:0]
+ANNOTATION_DEF -> ANNOTATION_DEF [49:0]
+|--MODIFIERS -> MODIFIERS [49:0]
+|   `--ANNOTATION -> ANNOTATION [49:0]
+|       |--AT -> @ [49:0]
+|       |--IDENT -> Target [49:1]
+|       |--LPAREN -> ( [49:7]
+|       |--ANNOTATION_ARRAY_INIT -> { [49:8]
+|       |   |--EXPR -> EXPR [49:21]
+|       |   |   `--DOT -> . [49:21]
+|       |   |       |--IDENT -> ElementType [49:10]
+|       |   |       `--IDENT -> TYPE_USE [49:22]
+|       |   |--COMMA -> , [49:30]
+|       |   |--EXPR -> EXPR [49:43]
+|       |   |   `--DOT -> . [49:43]
+|       |   |       |--IDENT -> ElementType [49:32]
+|       |   |       `--IDENT -> TYPE_PARAMETER [49:44]
+|       |   `--RCURLY -> } [49:59]
+|       `--RPAREN -> ) [49:60]
+|--AT -> @ [50:0]
+|--LITERAL_INTERFACE -> interface [50:1]
+|--IDENT -> TB [50:11]
+`--OBJBLOCK -> OBJBLOCK [50:14]
+    |--LCURLY -> { [50:14]
+    `--RCURLY -> } [51:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionNewLineAtEndOfFileCr.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionNewLineAtEndOfFileCr.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionNewLineAtEndOfFileCr.java
@@ -0,0 +1,16 @@
+////////////////////////////////////////////////////////////////////////////////
+// Test case file for checkstyle.
+// Created: 2015
+////////////////////////////////////////////////////////////////////////////////
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+/**
+ * Test case for detection of an existing CR newline at EOF, using the
+ * NewlineAtEndOfFileCheck.
+ * @author Martin Steiger
+ **/
+public interface InputAntlr4AstRegressionNewLineAtEndOfFileCr
+{
+/** Test with ending with CR newline
+*/
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionNewLineAtEndOfFileCr.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionNewLineAtEndOfFileCr.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionNewLineAtEndOfFileCr.txt
@@ -0,0 +1,22 @@
+PACKAGE_DEF -> package [5:0]
+|--ANNOTATIONS -> ANNOTATIONS [5:47]
+|--DOT -> . [5:47]
+|   |--DOT -> . [5:39]
+|   |   |--DOT -> . [5:28]
+|   |   |   |--DOT -> . [5:22]
+|   |   |   |   |--DOT -> . [5:11]
+|   |   |   |   |   |--IDENT -> com [5:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [5:12]
+|   |   |   |   `--IDENT -> tools [5:23]
+|   |   |   `--IDENT -> checkstyle [5:29]
+|   |   `--IDENT -> grammar [5:40]
+|   `--IDENT -> antlr4 [5:48]
+`--SEMI -> ; [5:54]
+INTERFACE_DEF -> INTERFACE_DEF [12:0]
+|--MODIFIERS -> MODIFIERS [12:0]
+|   `--LITERAL_PUBLIC -> public [12:0]
+|--LITERAL_INTERFACE -> interface [12:7]
+|--IDENT -> InputAntlr4AstRegressionNewLineAtEndOfFileCr [12:17]
+`--OBJBLOCK -> OBJBLOCK [13:0]
+    |--LCURLY -> { [13:0]
+    `--RCURLY -> } [16:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionNewTypeTree.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionNewTypeTree.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionNewTypeTree.java
@@ -0,0 +1,250 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import java.awt.*;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+import java.lang.reflect.AnnotatedElement;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeSet;
+
+import javax.net.ssl.KeyManager;
+
+public class InputAntlr4AstRegressionNewTypeTree {
+        private static class Slot {
+        double sin2Phi = 2 * StrictMath.sin(1.618033988749895);
+        public int[] ci;
+    }
+
+    private static class Transformer {
+
+    }
+
+    private static class Ef {
+        Transformer[] transformers = new Transformer[10];
+        static boolean forward = true;
+    }
+
+    void goodMethod() {
+        Slot slot = new Slot();
+        slot.ci[5] = 10; // ok
+        slot.ci = new int[6]; // ok
+        double[] cZ = {1.1, 1.2}; // ok
+        final double   dnZ = slot.sin2Phi               * cZ[1]; // ok
+
+        final Ef ef = new Ef();
+        final Transformer transformer =
+            ef.forward ? ef.transformers[ef.transformers.length - 1] // ok
+                    : ef.transformers[0]; // ok
+
+    }
+
+    void badMethod() {
+        Slot slot = new Slot();
+        slot.ci [5] = 10; // violation
+        slot.ci = new int [6]; // violation
+        double [] cZ = {1.1, 1.2}; // violation
+        final double   dnZ = slot.sin2Phi               * cZ [1]; // violation
+
+        final Ef ef = new Ef();
+        final Transformer transformer =
+            ef.forward ? ef.transformers [ef.transformers.length - 1] // violation
+                    : ef.transformers [0]; // violation
+
+        int[][
+                ]
+                 a
+                  []
+                        [] ; // violation
+                int[][
+                 ]
+                 b
+                 [] // violation
+                        [] ; // violation
+    }
+
+    void varargLong(@I String @L [] @K [] @J ... vararg2) { } // ok
+    @SuppressWarnings("unused")
+    void withUpperBound(List<? extends int[][]> list) {}
+
+    private static class SSLSecurity {
+        static KeyManager[] truncateArray(KeyManager[] kmaw,
+                                          KeyManager[] keyManagers) {
+            return null;
+        }
+    }
+
+
+    void method3(int x) {
+        KeyManager[] kmaw = null;
+         if (x == 1) {
+             kmaw = (javax.net.ssl.KeyManager[])
+                       SSLSecurity.truncateArray(kmaw,
+                           new javax.net.ssl.KeyManager [3]); // violation
+         }
+    }
+
+    enum FPMethodArgs {
+
+        IGNN,
+        IIGNN,
+        GNNII,
+        GNNC;
+
+        public Class<?>[] getMethodArguments(boolean isFPType) {
+            Class<?> N = (isFPType) ? Float.TYPE : Integer.TYPE;
+            Class<?> G = (isFPType) ? Graphics2D.class : Graphics.class;
+            switch (this) {
+                case IGNN:
+                    return new Class<?>[]{Integer.TYPE, G, N, N};
+                case IIGNN:
+                    return new Class<?>[]{Integer.TYPE, Integer.TYPE, G, N, N};
+                case GNNII:
+                    return new Class<?>[]{G, N, N, Integer.TYPE, Integer.TYPE};
+                case GNNC:
+                    return new Class<?>[]{G, N, N, Character.TYPE};
+                default:
+                    throw new RuntimeException("Unknown method arguments!");
+            }
+        }
+    }
+
+    public static class IntData {
+        int[] xorData;
+
+        IntData(Object srcPixel, Object xorPixel) {
+            this.xorData = (int[]) srcPixel; // violation
+            this.xorData = (int[]) xorPixel; // violation
+        }
+
+        protected void xorPixel(Object pixData) {
+            int[] dstData = (int[]) pixData; // violation
+            for (int i = 0; i < dstData.length; i++) {
+                dstData[i] ^= xorData[i];
+            }
+        }
+
+        Object[] getXorData() {
+            return new Object[5];
+        }
+
+        void method6() {
+            if (getXorData().length == 5
+                    && this.getXorData()[1] != IntData.class // ok
+                    || this.getXorData()[5] != IntData.class) {
+                System.out.println(getXorData().length);
+            }
+        }
+
+    }
+    protected TreeSet<byte []> sortedPrefixes = createTreeSet(); // violation
+
+    TreeSet<byte[]> createTreeSet() { // ok
+        return null;
+    } // ok
+
+    public Object newInstance(Object[] objects){
+            // Run constructor
+        InputAntlr4AstRegressionNewTypeTree tmpConstructor = null;
+        return tmpConstructor.newInstance((Object[])null);
+    }
+
+    public TypeVariable<Class<String>>[] getTypeParameters() {
+        ClassRepository info = getGenericInfo();
+        if (info != null)
+            return (TypeVariable<Class<String>>[])info.getTypeParameters();
+        else
+            return (TypeVariable<Class<String>>[])new TypeVariable<?>[0];
+    }
+    class ClassRepository {
+
+        public Object getTypeParameters() {
+            return null;
+        }
+    }
+    class TypeVariable<E> {
+
+    }
+
+    private ClassRepository getGenericInfo() {
+        return null;
+    }
+    String[] c, d[]; // ok
+    String [] e, f []; // violation
+
+    public enum Stooge {
+        MOE, CURLY, LARRY,
+    }
+    static void checkArrayTypes1(ArrayTypes at, AnnotatedElement e) {
+        if (!(at.cls()[0]  == Map.class    &&
+              at.e()[0]    == Stooge.MOE  )) {
+
+        }
+    }
+
+    static class ArrayTypes {
+        Object[] cls;
+
+        public Stooge[] e() {
+            return null;
+        }
+
+
+
+        Object[] cls() {
+            return cls;
+        }
+
+        public int[] a() {
+            return null;
+        }
+    }
+    int[][
+    ]
+     w
+     [] // violation
+            [] ; // violation
+    int[][
+     ]
+     z
+    [] // violation
+            [] ; // violation
+
+    static class P {
+        private int x;
+
+        public void set3(P p) {
+              synchronized (this) { // violation
+                  p.x = get()[0];
+              }
+          }
+
+        public void set4(P p) {
+              synchronized(this) { // ok
+                  p.x = get()[0];
+              }
+          }
+
+        private int[] get() {
+            return null;
+        }
+    }
+
+    private @Nullable int array2 @Nullable [] @Nullable [];
+}
+
+
+@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
+@interface Nullable{}
+
+@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
+@interface I {}
+
+@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
+@interface J {}
+
+@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
+@interface K {}
+
+@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
+@interface L {}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionNewTypeTree.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionNewTypeTree.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionNewTypeTree.txt
@@ -0,0 +1,1807 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+IMPORT -> import [3:0]
+|--DOT -> . [3:15]
+|   |--DOT -> . [3:11]
+|   |   |--IDENT -> java [3:7]
+|   |   `--IDENT -> awt [3:12]
+|   `--STAR -> * [3:16]
+`--SEMI -> ; [3:17]
+IMPORT -> import [4:0]
+|--DOT -> . [4:27]
+|   |--DOT -> . [4:16]
+|   |   |--DOT -> . [4:11]
+|   |   |   |--IDENT -> java [4:7]
+|   |   |   `--IDENT -> lang [4:12]
+|   |   `--IDENT -> annotation [4:17]
+|   `--IDENT -> ElementType [4:28]
+`--SEMI -> ; [4:39]
+IMPORT -> import [5:0]
+|--DOT -> . [5:27]
+|   |--DOT -> . [5:16]
+|   |   |--DOT -> . [5:11]
+|   |   |   |--IDENT -> java [5:7]
+|   |   |   `--IDENT -> lang [5:12]
+|   |   `--IDENT -> annotation [5:17]
+|   `--IDENT -> Target [5:28]
+`--SEMI -> ; [5:34]
+IMPORT -> import [6:0]
+|--DOT -> . [6:24]
+|   |--DOT -> . [6:16]
+|   |   |--DOT -> . [6:11]
+|   |   |   |--IDENT -> java [6:7]
+|   |   |   `--IDENT -> lang [6:12]
+|   |   `--IDENT -> reflect [6:17]
+|   `--IDENT -> AnnotatedElement [6:25]
+`--SEMI -> ; [6:41]
+IMPORT -> import [7:0]
+|--DOT -> . [7:16]
+|   |--DOT -> . [7:11]
+|   |   |--IDENT -> java [7:7]
+|   |   `--IDENT -> util [7:12]
+|   `--IDENT -> List [7:17]
+`--SEMI -> ; [7:21]
+IMPORT -> import [8:0]
+|--DOT -> . [8:16]
+|   |--DOT -> . [8:11]
+|   |   |--IDENT -> java [8:7]
+|   |   `--IDENT -> util [8:12]
+|   `--IDENT -> Map [8:17]
+`--SEMI -> ; [8:20]
+IMPORT -> import [9:0]
+|--DOT -> . [9:16]
+|   |--DOT -> . [9:11]
+|   |   |--IDENT -> java [9:7]
+|   |   `--IDENT -> util [9:12]
+|   `--IDENT -> TreeSet [9:17]
+`--SEMI -> ; [9:24]
+IMPORT -> import [11:0]
+|--DOT -> . [11:20]
+|   |--DOT -> . [11:16]
+|   |   |--DOT -> . [11:12]
+|   |   |   |--IDENT -> javax [11:7]
+|   |   |   `--IDENT -> net [11:13]
+|   |   `--IDENT -> ssl [11:17]
+|   `--IDENT -> KeyManager [11:21]
+`--SEMI -> ; [11:31]
+CLASS_DEF -> CLASS_DEF [13:0]
+|--MODIFIERS -> MODIFIERS [13:0]
+|   `--LITERAL_PUBLIC -> public [13:0]
+|--LITERAL_CLASS -> class [13:7]
+|--IDENT -> InputAntlr4AstRegressionNewTypeTree [13:13]
+`--OBJBLOCK -> OBJBLOCK [13:49]
+    |--LCURLY -> { [13:49]
+    |--CLASS_DEF -> CLASS_DEF [14:8]
+    |   |--MODIFIERS -> MODIFIERS [14:8]
+    |   |   |--LITERAL_PRIVATE -> private [14:8]
+    |   |   `--LITERAL_STATIC -> static [14:16]
+    |   |--LITERAL_CLASS -> class [14:23]
+    |   |--IDENT -> Slot [14:29]
+    |   `--OBJBLOCK -> OBJBLOCK [14:34]
+    |       |--LCURLY -> { [14:34]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [15:8]
+    |       |   |--MODIFIERS -> MODIFIERS [15:8]
+    |       |   |--TYPE -> TYPE [15:8]
+    |       |   |   `--LITERAL_DOUBLE -> double [15:8]
+    |       |   |--IDENT -> sin2Phi [15:15]
+    |       |   |--ASSIGN -> = [15:23]
+    |       |   |   `--EXPR -> EXPR [15:27]
+    |       |   |       `--STAR -> * [15:27]
+    |       |   |           |--NUM_INT -> 2 [15:25]
+    |       |   |           `--METHOD_CALL -> ( [15:43]
+    |       |   |               |--DOT -> . [15:39]
+    |       |   |               |   |--IDENT -> StrictMath [15:29]
+    |       |   |               |   `--IDENT -> sin [15:40]
+    |       |   |               |--ELIST -> ELIST [15:44]
+    |       |   |               |   `--EXPR -> EXPR [15:44]
+    |       |   |               |       `--NUM_FLOAT -> 1.618033988749895 [15:44]
+    |       |   |               `--RPAREN -> ) [15:61]
+    |       |   `--SEMI -> ; [15:62]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [16:8]
+    |       |   |--MODIFIERS -> MODIFIERS [16:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [16:8]
+    |       |   |--TYPE -> TYPE [16:15]
+    |       |   |   |--LITERAL_INT -> int [16:15]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [16:18]
+    |       |   |       `--RBRACK -> ] [16:19]
+    |       |   |--IDENT -> ci [16:21]
+    |       |   `--SEMI -> ; [16:23]
+    |       `--RCURLY -> } [17:4]
+    |--CLASS_DEF -> CLASS_DEF [19:4]
+    |   |--MODIFIERS -> MODIFIERS [19:4]
+    |   |   |--LITERAL_PRIVATE -> private [19:4]
+    |   |   `--LITERAL_STATIC -> static [19:12]
+    |   |--LITERAL_CLASS -> class [19:19]
+    |   |--IDENT -> Transformer [19:25]
+    |   `--OBJBLOCK -> OBJBLOCK [19:37]
+    |       |--LCURLY -> { [19:37]
+    |       `--RCURLY -> } [21:4]
+    |--CLASS_DEF -> CLASS_DEF [23:4]
+    |   |--MODIFIERS -> MODIFIERS [23:4]
+    |   |   |--LITERAL_PRIVATE -> private [23:4]
+    |   |   `--LITERAL_STATIC -> static [23:12]
+    |   |--LITERAL_CLASS -> class [23:19]
+    |   |--IDENT -> Ef [23:25]
+    |   `--OBJBLOCK -> OBJBLOCK [23:28]
+    |       |--LCURLY -> { [23:28]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [24:8]
+    |       |   |--MODIFIERS -> MODIFIERS [24:8]
+    |       |   |--TYPE -> TYPE [24:8]
+    |       |   |   |--IDENT -> Transformer [24:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [24:19]
+    |       |   |       `--RBRACK -> ] [24:20]
+    |       |   |--IDENT -> transformers [24:22]
+    |       |   |--ASSIGN -> = [24:35]
+    |       |   |   `--EXPR -> EXPR [24:37]
+    |       |   |       `--LITERAL_NEW -> new [24:37]
+    |       |   |           |--IDENT -> Transformer [24:41]
+    |       |   |           `--ARRAY_DECLARATOR -> [ [24:52]
+    |       |   |               |--EXPR -> EXPR [24:53]
+    |       |   |               |   `--NUM_INT -> 10 [24:53]
+    |       |   |               `--RBRACK -> ] [24:55]
+    |       |   `--SEMI -> ; [24:56]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [25:8]
+    |       |   |--MODIFIERS -> MODIFIERS [25:8]
+    |       |   |   `--LITERAL_STATIC -> static [25:8]
+    |       |   |--TYPE -> TYPE [25:15]
+    |       |   |   `--LITERAL_BOOLEAN -> boolean [25:15]
+    |       |   |--IDENT -> forward [25:23]
+    |       |   |--ASSIGN -> = [25:31]
+    |       |   |   `--EXPR -> EXPR [25:33]
+    |       |   |       `--LITERAL_TRUE -> true [25:33]
+    |       |   `--SEMI -> ; [25:37]
+    |       `--RCURLY -> } [26:4]
+    |--METHOD_DEF -> METHOD_DEF [28:4]
+    |   |--MODIFIERS -> MODIFIERS [28:4]
+    |   |--TYPE -> TYPE [28:4]
+    |   |   `--LITERAL_VOID -> void [28:4]
+    |   |--IDENT -> goodMethod [28:9]
+    |   |--LPAREN -> ( [28:19]
+    |   |--PARAMETERS -> PARAMETERS [28:20]
+    |   |--RPAREN -> ) [28:20]
+    |   `--SLIST -> { [28:22]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [29:8]
+    |       |   |--MODIFIERS -> MODIFIERS [29:8]
+    |       |   |--TYPE -> TYPE [29:8]
+    |       |   |   `--IDENT -> Slot [29:8]
+    |       |   |--IDENT -> slot [29:13]
+    |       |   `--ASSIGN -> = [29:18]
+    |       |       `--EXPR -> EXPR [29:20]
+    |       |           `--LITERAL_NEW -> new [29:20]
+    |       |               |--IDENT -> Slot [29:24]
+    |       |               |--LPAREN -> ( [29:28]
+    |       |               |--ELIST -> ELIST [29:29]
+    |       |               `--RPAREN -> ) [29:29]
+    |       |--SEMI -> ; [29:30]
+    |       |--EXPR -> EXPR [30:19]
+    |       |   `--ASSIGN -> = [30:19]
+    |       |       |--INDEX_OP -> [ [30:15]
+    |       |       |   |--DOT -> . [30:12]
+    |       |       |   |   |--IDENT -> slot [30:8]
+    |       |       |   |   `--IDENT -> ci [30:13]
+    |       |       |   |--EXPR -> EXPR [30:16]
+    |       |       |   |   `--NUM_INT -> 5 [30:16]
+    |       |       |   `--RBRACK -> ] [30:17]
+    |       |       `--NUM_INT -> 10 [30:21]
+    |       |--SEMI -> ; [30:23]
+    |       |--EXPR -> EXPR [31:16]
+    |       |   `--ASSIGN -> = [31:16]
+    |       |       |--DOT -> . [31:12]
+    |       |       |   |--IDENT -> slot [31:8]
+    |       |       |   `--IDENT -> ci [31:13]
+    |       |       `--LITERAL_NEW -> new [31:18]
+    |       |           |--LITERAL_INT -> int [31:22]
+    |       |           `--ARRAY_DECLARATOR -> [ [31:25]
+    |       |               |--EXPR -> EXPR [31:26]
+    |       |               |   `--NUM_INT -> 6 [31:26]
+    |       |               `--RBRACK -> ] [31:27]
+    |       |--SEMI -> ; [31:28]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [32:8]
+    |       |   |--MODIFIERS -> MODIFIERS [32:8]
+    |       |   |--TYPE -> TYPE [32:8]
+    |       |   |   |--LITERAL_DOUBLE -> double [32:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [32:14]
+    |       |   |       `--RBRACK -> ] [32:15]
+    |       |   |--IDENT -> cZ [32:17]
+    |       |   `--ASSIGN -> = [32:20]
+    |       |       `--ARRAY_INIT -> { [32:22]
+    |       |           |--EXPR -> EXPR [32:23]
+    |       |           |   `--NUM_FLOAT -> 1.1 [32:23]
+    |       |           |--COMMA -> , [32:26]
+    |       |           |--EXPR -> EXPR [32:28]
+    |       |           |   `--NUM_FLOAT -> 1.2 [32:28]
+    |       |           `--RCURLY -> } [32:31]
+    |       |--SEMI -> ; [32:32]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [33:8]
+    |       |   |--MODIFIERS -> MODIFIERS [33:8]
+    |       |   |   `--FINAL -> final [33:8]
+    |       |   |--TYPE -> TYPE [33:14]
+    |       |   |   `--LITERAL_DOUBLE -> double [33:14]
+    |       |   |--IDENT -> dnZ [33:23]
+    |       |   `--ASSIGN -> = [33:27]
+    |       |       `--EXPR -> EXPR [33:56]
+    |       |           `--STAR -> * [33:56]
+    |       |               |--DOT -> . [33:33]
+    |       |               |   |--IDENT -> slot [33:29]
+    |       |               |   `--IDENT -> sin2Phi [33:34]
+    |       |               `--INDEX_OP -> [ [33:60]
+    |       |                   |--IDENT -> cZ [33:58]
+    |       |                   |--EXPR -> EXPR [33:61]
+    |       |                   |   `--NUM_INT -> 1 [33:61]
+    |       |                   `--RBRACK -> ] [33:62]
+    |       |--SEMI -> ; [33:63]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [35:8]
+    |       |   |--MODIFIERS -> MODIFIERS [35:8]
+    |       |   |   `--FINAL -> final [35:8]
+    |       |   |--TYPE -> TYPE [35:14]
+    |       |   |   `--IDENT -> Ef [35:14]
+    |       |   |--IDENT -> ef [35:17]
+    |       |   `--ASSIGN -> = [35:20]
+    |       |       `--EXPR -> EXPR [35:22]
+    |       |           `--LITERAL_NEW -> new [35:22]
+    |       |               |--IDENT -> Ef [35:26]
+    |       |               |--LPAREN -> ( [35:28]
+    |       |               |--ELIST -> ELIST [35:29]
+    |       |               `--RPAREN -> ) [35:29]
+    |       |--SEMI -> ; [35:30]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [36:8]
+    |       |   |--MODIFIERS -> MODIFIERS [36:8]
+    |       |   |   `--FINAL -> final [36:8]
+    |       |   |--TYPE -> TYPE [36:14]
+    |       |   |   `--IDENT -> Transformer [36:14]
+    |       |   |--IDENT -> transformer [36:26]
+    |       |   `--ASSIGN -> = [36:38]
+    |       |       `--EXPR -> EXPR [37:23]
+    |       |           `--QUESTION -> ? [37:23]
+    |       |               |--DOT -> . [37:14]
+    |       |               |   |--IDENT -> ef [37:12]
+    |       |               |   `--IDENT -> forward [37:15]
+    |       |               |--INDEX_OP -> [ [37:40]
+    |       |               |   |--DOT -> . [37:27]
+    |       |               |   |   |--IDENT -> ef [37:25]
+    |       |               |   |   `--IDENT -> transformers [37:28]
+    |       |               |   |--EXPR -> EXPR [37:64]
+    |       |               |   |   `--MINUS -> - [37:64]
+    |       |               |   |       |--DOT -> . [37:56]
+    |       |               |   |       |   |--DOT -> . [37:43]
+    |       |               |   |       |   |   |--IDENT -> ef [37:41]
+    |       |               |   |       |   |   `--IDENT -> transformers [37:44]
+    |       |               |   |       |   `--IDENT -> length [37:57]
+    |       |               |   |       `--NUM_INT -> 1 [37:66]
+    |       |               |   `--RBRACK -> ] [37:67]
+    |       |               |--COLON -> : [38:20]
+    |       |               `--INDEX_OP -> [ [38:37]
+    |       |                   |--DOT -> . [38:24]
+    |       |                   |   |--IDENT -> ef [38:22]
+    |       |                   |   `--IDENT -> transformers [38:25]
+    |       |                   |--EXPR -> EXPR [38:38]
+    |       |                   |   `--NUM_INT -> 0 [38:38]
+    |       |                   `--RBRACK -> ] [38:39]
+    |       |--SEMI -> ; [38:40]
+    |       `--RCURLY -> } [40:4]
+    |--METHOD_DEF -> METHOD_DEF [42:4]
+    |   |--MODIFIERS -> MODIFIERS [42:4]
+    |   |--TYPE -> TYPE [42:4]
+    |   |   `--LITERAL_VOID -> void [42:4]
+    |   |--IDENT -> badMethod [42:9]
+    |   |--LPAREN -> ( [42:18]
+    |   |--PARAMETERS -> PARAMETERS [42:19]
+    |   |--RPAREN -> ) [42:19]
+    |   `--SLIST -> { [42:21]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [43:8]
+    |       |   |--MODIFIERS -> MODIFIERS [43:8]
+    |       |   |--TYPE -> TYPE [43:8]
+    |       |   |   `--IDENT -> Slot [43:8]
+    |       |   |--IDENT -> slot [43:13]
+    |       |   `--ASSIGN -> = [43:18]
+    |       |       `--EXPR -> EXPR [43:20]
+    |       |           `--LITERAL_NEW -> new [43:20]
+    |       |               |--IDENT -> Slot [43:24]
+    |       |               |--LPAREN -> ( [43:28]
+    |       |               |--ELIST -> ELIST [43:29]
+    |       |               `--RPAREN -> ) [43:29]
+    |       |--SEMI -> ; [43:30]
+    |       |--EXPR -> EXPR [44:20]
+    |       |   `--ASSIGN -> = [44:20]
+    |       |       |--INDEX_OP -> [ [44:16]
+    |       |       |   |--DOT -> . [44:12]
+    |       |       |   |   |--IDENT -> slot [44:8]
+    |       |       |   |   `--IDENT -> ci [44:13]
+    |       |       |   |--EXPR -> EXPR [44:17]
+    |       |       |   |   `--NUM_INT -> 5 [44:17]
+    |       |       |   `--RBRACK -> ] [44:18]
+    |       |       `--NUM_INT -> 10 [44:22]
+    |       |--SEMI -> ; [44:24]
+    |       |--EXPR -> EXPR [45:16]
+    |       |   `--ASSIGN -> = [45:16]
+    |       |       |--DOT -> . [45:12]
+    |       |       |   |--IDENT -> slot [45:8]
+    |       |       |   `--IDENT -> ci [45:13]
+    |       |       `--LITERAL_NEW -> new [45:18]
+    |       |           |--LITERAL_INT -> int [45:22]
+    |       |           `--ARRAY_DECLARATOR -> [ [45:26]
+    |       |               |--EXPR -> EXPR [45:27]
+    |       |               |   `--NUM_INT -> 6 [45:27]
+    |       |               `--RBRACK -> ] [45:28]
+    |       |--SEMI -> ; [45:29]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [46:8]
+    |       |   |--MODIFIERS -> MODIFIERS [46:8]
+    |       |   |--TYPE -> TYPE [46:8]
+    |       |   |   |--LITERAL_DOUBLE -> double [46:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [46:15]
+    |       |   |       `--RBRACK -> ] [46:16]
+    |       |   |--IDENT -> cZ [46:18]
+    |       |   `--ASSIGN -> = [46:21]
+    |       |       `--ARRAY_INIT -> { [46:23]
+    |       |           |--EXPR -> EXPR [46:24]
+    |       |           |   `--NUM_FLOAT -> 1.1 [46:24]
+    |       |           |--COMMA -> , [46:27]
+    |       |           |--EXPR -> EXPR [46:29]
+    |       |           |   `--NUM_FLOAT -> 1.2 [46:29]
+    |       |           `--RCURLY -> } [46:32]
+    |       |--SEMI -> ; [46:33]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [47:8]
+    |       |   |--MODIFIERS -> MODIFIERS [47:8]
+    |       |   |   `--FINAL -> final [47:8]
+    |       |   |--TYPE -> TYPE [47:14]
+    |       |   |   `--LITERAL_DOUBLE -> double [47:14]
+    |       |   |--IDENT -> dnZ [47:23]
+    |       |   `--ASSIGN -> = [47:27]
+    |       |       `--EXPR -> EXPR [47:56]
+    |       |           `--STAR -> * [47:56]
+    |       |               |--DOT -> . [47:33]
+    |       |               |   |--IDENT -> slot [47:29]
+    |       |               |   `--IDENT -> sin2Phi [47:34]
+    |       |               `--INDEX_OP -> [ [47:61]
+    |       |                   |--IDENT -> cZ [47:58]
+    |       |                   |--EXPR -> EXPR [47:62]
+    |       |                   |   `--NUM_INT -> 1 [47:62]
+    |       |                   `--RBRACK -> ] [47:63]
+    |       |--SEMI -> ; [47:64]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [49:8]
+    |       |   |--MODIFIERS -> MODIFIERS [49:8]
+    |       |   |   `--FINAL -> final [49:8]
+    |       |   |--TYPE -> TYPE [49:14]
+    |       |   |   `--IDENT -> Ef [49:14]
+    |       |   |--IDENT -> ef [49:17]
+    |       |   `--ASSIGN -> = [49:20]
+    |       |       `--EXPR -> EXPR [49:22]
+    |       |           `--LITERAL_NEW -> new [49:22]
+    |       |               |--IDENT -> Ef [49:26]
+    |       |               |--LPAREN -> ( [49:28]
+    |       |               |--ELIST -> ELIST [49:29]
+    |       |               `--RPAREN -> ) [49:29]
+    |       |--SEMI -> ; [49:30]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [50:8]
+    |       |   |--MODIFIERS -> MODIFIERS [50:8]
+    |       |   |   `--FINAL -> final [50:8]
+    |       |   |--TYPE -> TYPE [50:14]
+    |       |   |   `--IDENT -> Transformer [50:14]
+    |       |   |--IDENT -> transformer [50:26]
+    |       |   `--ASSIGN -> = [50:38]
+    |       |       `--EXPR -> EXPR [51:23]
+    |       |           `--QUESTION -> ? [51:23]
+    |       |               |--DOT -> . [51:14]
+    |       |               |   |--IDENT -> ef [51:12]
+    |       |               |   `--IDENT -> forward [51:15]
+    |       |               |--INDEX_OP -> [ [51:41]
+    |       |               |   |--DOT -> . [51:27]
+    |       |               |   |   |--IDENT -> ef [51:25]
+    |       |               |   |   `--IDENT -> transformers [51:28]
+    |       |               |   |--EXPR -> EXPR [51:65]
+    |       |               |   |   `--MINUS -> - [51:65]
+    |       |               |   |       |--DOT -> . [51:57]
+    |       |               |   |       |   |--DOT -> . [51:44]
+    |       |               |   |       |   |   |--IDENT -> ef [51:42]
+    |       |               |   |       |   |   `--IDENT -> transformers [51:45]
+    |       |               |   |       |   `--IDENT -> length [51:58]
+    |       |               |   |       `--NUM_INT -> 1 [51:67]
+    |       |               |   `--RBRACK -> ] [51:68]
+    |       |               |--COLON -> : [52:20]
+    |       |               `--INDEX_OP -> [ [52:38]
+    |       |                   |--DOT -> . [52:24]
+    |       |                   |   |--IDENT -> ef [52:22]
+    |       |                   |   `--IDENT -> transformers [52:25]
+    |       |                   |--EXPR -> EXPR [52:39]
+    |       |                   |   `--NUM_INT -> 0 [52:39]
+    |       |                   `--RBRACK -> ] [52:40]
+    |       |--SEMI -> ; [52:41]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [54:8]
+    |       |   |--MODIFIERS -> MODIFIERS [54:8]
+    |       |   |--TYPE -> TYPE [54:8]
+    |       |   |   |--LITERAL_INT -> int [54:8]
+    |       |   |   |--ARRAY_DECLARATOR -> [ [54:11]
+    |       |   |   |   `--RBRACK -> ] [54:12]
+    |       |   |   |--ARRAY_DECLARATOR -> [ [54:13]
+    |       |   |   |   `--RBRACK -> ] [55:16]
+    |       |   |   |--ARRAY_DECLARATOR -> [ [57:18]
+    |       |   |   |   `--RBRACK -> ] [57:19]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [58:24]
+    |       |   |       `--RBRACK -> ] [58:25]
+    |       |   `--IDENT -> a [56:17]
+    |       |--SEMI -> ; [58:27]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [59:16]
+    |       |   |--MODIFIERS -> MODIFIERS [59:16]
+    |       |   |--TYPE -> TYPE [59:16]
+    |       |   |   |--LITERAL_INT -> int [59:16]
+    |       |   |   |--ARRAY_DECLARATOR -> [ [59:19]
+    |       |   |   |   `--RBRACK -> ] [59:20]
+    |       |   |   |--ARRAY_DECLARATOR -> [ [59:21]
+    |       |   |   |   `--RBRACK -> ] [60:17]
+    |       |   |   |--ARRAY_DECLARATOR -> [ [62:17]
+    |       |   |   |   `--RBRACK -> ] [62:18]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [63:24]
+    |       |   |       `--RBRACK -> ] [63:25]
+    |       |   `--IDENT -> b [61:17]
+    |       |--SEMI -> ; [63:27]
+    |       `--RCURLY -> } [64:4]
+    |--METHOD_DEF -> METHOD_DEF [66:4]
+    |   |--MODIFIERS -> MODIFIERS [66:4]
+    |   |--TYPE -> TYPE [66:4]
+    |   |   `--LITERAL_VOID -> void [66:4]
+    |   |--IDENT -> varargLong [66:9]
+    |   |--LPAREN -> ( [66:19]
+    |   |--PARAMETERS -> PARAMETERS [66:20]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [66:20]
+    |   |       |--MODIFIERS -> MODIFIERS [66:20]
+    |   |       |   `--ANNOTATION -> ANNOTATION [66:20]
+    |   |       |       |--AT -> @ [66:20]
+    |   |       |       `--IDENT -> I [66:21]
+    |   |       |--TYPE -> TYPE [66:23]
+    |   |       |   |--IDENT -> String [66:23]
+    |   |       |   |--ANNOTATIONS -> ANNOTATIONS [66:30]
+    |   |       |   |   `--ANNOTATION -> ANNOTATION [66:30]
+    |   |       |   |       |--AT -> @ [66:30]
+    |   |       |   |       `--IDENT -> L [66:31]
+    |   |       |   |--ARRAY_DECLARATOR -> [ [66:33]
+    |   |       |   |   `--RBRACK -> ] [66:34]
+    |   |       |   |--ANNOTATIONS -> ANNOTATIONS [66:36]
+    |   |       |   |   `--ANNOTATION -> ANNOTATION [66:36]
+    |   |       |   |       |--AT -> @ [66:36]
+    |   |       |   |       `--IDENT -> K [66:37]
+    |   |       |   |--ARRAY_DECLARATOR -> [ [66:39]
+    |   |       |   |   `--RBRACK -> ] [66:40]
+    |   |       |   `--ANNOTATIONS -> ANNOTATIONS [66:42]
+    |   |       |       `--ANNOTATION -> ANNOTATION [66:42]
+    |   |       |           |--AT -> @ [66:42]
+    |   |       |           `--IDENT -> J [66:43]
+    |   |       |--ELLIPSIS -> ... [66:45]
+    |   |       `--IDENT -> vararg2 [66:49]
+    |   |--RPAREN -> ) [66:56]
+    |   `--SLIST -> { [66:58]
+    |       `--RCURLY -> } [66:60]
+    |--METHOD_DEF -> METHOD_DEF [67:4]
+    |   |--MODIFIERS -> MODIFIERS [67:4]
+    |   |   `--ANNOTATION -> ANNOTATION [67:4]
+    |   |       |--AT -> @ [67:4]
+    |   |       |--IDENT -> SuppressWarnings [67:5]
+    |   |       |--LPAREN -> ( [67:21]
+    |   |       |--EXPR -> EXPR [67:22]
+    |   |       |   `--STRING_LITERAL -> "unused" [67:22]
+    |   |       `--RPAREN -> ) [67:30]
+    |   |--TYPE -> TYPE [68:4]
+    |   |   `--LITERAL_VOID -> void [68:4]
+    |   |--IDENT -> withUpperBound [68:9]
+    |   |--LPAREN -> ( [68:23]
+    |   |--PARAMETERS -> PARAMETERS [68:24]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [68:24]
+    |   |       |--MODIFIERS -> MODIFIERS [68:24]
+    |   |       |--TYPE -> TYPE [68:24]
+    |   |       |   |--IDENT -> List [68:24]
+    |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [68:28]
+    |   |       |       |--GENERIC_START -> < [68:28]
+    |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [68:29]
+    |   |       |       |   |--WILDCARD_TYPE -> ? [68:29]
+    |   |       |       |   `--TYPE_UPPER_BOUNDS -> extends [68:31]
+    |   |       |       |       |--LITERAL_INT -> int [68:39]
+    |   |       |       |       |--ARRAY_DECLARATOR -> [ [68:42]
+    |   |       |       |       |   `--RBRACK -> ] [68:43]
+    |   |       |       |       `--ARRAY_DECLARATOR -> [ [68:44]
+    |   |       |       |           `--RBRACK -> ] [68:45]
+    |   |       |       `--GENERIC_END -> > [68:46]
+    |   |       `--IDENT -> list [68:48]
+    |   |--RPAREN -> ) [68:52]
+    |   `--SLIST -> { [68:54]
+    |       `--RCURLY -> } [68:55]
+    |--CLASS_DEF -> CLASS_DEF [70:4]
+    |   |--MODIFIERS -> MODIFIERS [70:4]
+    |   |   |--LITERAL_PRIVATE -> private [70:4]
+    |   |   `--LITERAL_STATIC -> static [70:12]
+    |   |--LITERAL_CLASS -> class [70:19]
+    |   |--IDENT -> SSLSecurity [70:25]
+    |   `--OBJBLOCK -> OBJBLOCK [70:37]
+    |       |--LCURLY -> { [70:37]
+    |       |--METHOD_DEF -> METHOD_DEF [71:8]
+    |       |   |--MODIFIERS -> MODIFIERS [71:8]
+    |       |   |   `--LITERAL_STATIC -> static [71:8]
+    |       |   |--TYPE -> TYPE [71:15]
+    |       |   |   |--IDENT -> KeyManager [71:15]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [71:25]
+    |       |   |       `--RBRACK -> ] [71:26]
+    |       |   |--IDENT -> truncateArray [71:28]
+    |       |   |--LPAREN -> ( [71:41]
+    |       |   |--PARAMETERS -> PARAMETERS [71:42]
+    |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [71:42]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [71:42]
+    |       |   |   |   |--TYPE -> TYPE [71:42]
+    |       |   |   |   |   |--IDENT -> KeyManager [71:42]
+    |       |   |   |   |   `--ARRAY_DECLARATOR -> [ [71:52]
+    |       |   |   |   |       `--RBRACK -> ] [71:53]
+    |       |   |   |   `--IDENT -> kmaw [71:55]
+    |       |   |   |--COMMA -> , [71:59]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [72:42]
+    |       |   |       |--MODIFIERS -> MODIFIERS [72:42]
+    |       |   |       |--TYPE -> TYPE [72:42]
+    |       |   |       |   |--IDENT -> KeyManager [72:42]
+    |       |   |       |   `--ARRAY_DECLARATOR -> [ [72:52]
+    |       |   |       |       `--RBRACK -> ] [72:53]
+    |       |   |       `--IDENT -> keyManagers [72:55]
+    |       |   |--RPAREN -> ) [72:66]
+    |       |   `--SLIST -> { [72:68]
+    |       |       |--LITERAL_RETURN -> return [73:12]
+    |       |       |   |--EXPR -> EXPR [73:19]
+    |       |       |   |   `--LITERAL_NULL -> null [73:19]
+    |       |       |   `--SEMI -> ; [73:23]
+    |       |       `--RCURLY -> } [74:8]
+    |       `--RCURLY -> } [75:4]
+    |--METHOD_DEF -> METHOD_DEF [78:4]
+    |   |--MODIFIERS -> MODIFIERS [78:4]
+    |   |--TYPE -> TYPE [78:4]
+    |   |   `--LITERAL_VOID -> void [78:4]
+    |   |--IDENT -> method3 [78:9]
+    |   |--LPAREN -> ( [78:16]
+    |   |--PARAMETERS -> PARAMETERS [78:17]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [78:17]
+    |   |       |--MODIFIERS -> MODIFIERS [78:17]
+    |   |       |--TYPE -> TYPE [78:17]
+    |   |       |   `--LITERAL_INT -> int [78:17]
+    |   |       `--IDENT -> x [78:21]
+    |   |--RPAREN -> ) [78:22]
+    |   `--SLIST -> { [78:24]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [79:8]
+    |       |   |--MODIFIERS -> MODIFIERS [79:8]
+    |       |   |--TYPE -> TYPE [79:8]
+    |       |   |   |--IDENT -> KeyManager [79:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [79:18]
+    |       |   |       `--RBRACK -> ] [79:19]
+    |       |   |--IDENT -> kmaw [79:21]
+    |       |   `--ASSIGN -> = [79:26]
+    |       |       `--EXPR -> EXPR [79:28]
+    |       |           `--LITERAL_NULL -> null [79:28]
+    |       |--SEMI -> ; [79:32]
+    |       |--LITERAL_IF -> if [80:9]
+    |       |   |--LPAREN -> ( [80:12]
+    |       |   |--EXPR -> EXPR [80:15]
+    |       |   |   `--EQUAL -> == [80:15]
+    |       |   |       |--IDENT -> x [80:13]
+    |       |   |       `--NUM_INT -> 1 [80:18]
+    |       |   |--RPAREN -> ) [80:19]
+    |       |   `--SLIST -> { [80:21]
+    |       |       |--EXPR -> EXPR [81:18]
+    |       |       |   `--ASSIGN -> = [81:18]
+    |       |       |       |--IDENT -> kmaw [81:13]
+    |       |       |       `--TYPECAST -> ( [81:20]
+    |       |       |           |--TYPE -> TYPE [81:34]
+    |       |       |           |   |--DOT -> . [81:34]
+    |       |       |           |   |   |--DOT -> . [81:30]
+    |       |       |           |   |   |   |--DOT -> . [81:26]
+    |       |       |           |   |   |   |   |--IDENT -> javax [81:21]
+    |       |       |           |   |   |   |   `--IDENT -> net [81:27]
+    |       |       |           |   |   |   `--IDENT -> ssl [81:31]
+    |       |       |           |   |   `--IDENT -> KeyManager [81:35]
+    |       |       |           |   `--ARRAY_DECLARATOR -> [ [81:45]
+    |       |       |           |       `--RBRACK -> ] [81:46]
+    |       |       |           |--RPAREN -> ) [81:47]
+    |       |       |           `--METHOD_CALL -> ( [82:48]
+    |       |       |               |--DOT -> . [82:34]
+    |       |       |               |   |--IDENT -> SSLSecurity [82:23]
+    |       |       |               |   `--IDENT -> truncateArray [82:35]
+    |       |       |               |--ELIST -> ELIST [82:49]
+    |       |       |               |   |--EXPR -> EXPR [82:49]
+    |       |       |               |   |   `--IDENT -> kmaw [82:49]
+    |       |       |               |   |--COMMA -> , [82:53]
+    |       |       |               |   `--EXPR -> EXPR [83:27]
+    |       |       |               |       `--LITERAL_NEW -> new [83:27]
+    |       |       |               |           |--DOT -> . [83:44]
+    |       |       |               |           |   |--DOT -> . [83:40]
+    |       |       |               |           |   |   |--DOT -> . [83:36]
+    |       |       |               |           |   |   |   |--IDENT -> javax [83:31]
+    |       |       |               |           |   |   |   `--IDENT -> net [83:37]
+    |       |       |               |           |   |   `--IDENT -> ssl [83:41]
+    |       |       |               |           |   `--IDENT -> KeyManager [83:45]
+    |       |       |               |           `--ARRAY_DECLARATOR -> [ [83:56]
+    |       |       |               |               |--EXPR -> EXPR [83:57]
+    |       |       |               |               |   `--NUM_INT -> 3 [83:57]
+    |       |       |               |               `--RBRACK -> ] [83:58]
+    |       |       |               `--RPAREN -> ) [83:59]
+    |       |       |--SEMI -> ; [83:60]
+    |       |       `--RCURLY -> } [84:9]
+    |       `--RCURLY -> } [85:4]
+    |--ENUM_DEF -> ENUM_DEF [87:4]
+    |   |--MODIFIERS -> MODIFIERS [87:4]
+    |   |--ENUM -> enum [87:4]
+    |   |--IDENT -> FPMethodArgs [87:9]
+    |   `--OBJBLOCK -> OBJBLOCK [87:22]
+    |       |--LCURLY -> { [87:22]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [89:8]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [89:8]
+    |       |   `--IDENT -> IGNN [89:8]
+    |       |--COMMA -> , [89:12]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [90:8]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [90:8]
+    |       |   `--IDENT -> IIGNN [90:8]
+    |       |--COMMA -> , [90:13]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [91:8]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [91:8]
+    |       |   `--IDENT -> GNNII [91:8]
+    |       |--COMMA -> , [91:13]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [92:8]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [92:8]
+    |       |   `--IDENT -> GNNC [92:8]
+    |       |--SEMI -> ; [92:12]
+    |       |--METHOD_DEF -> METHOD_DEF [94:8]
+    |       |   |--MODIFIERS -> MODIFIERS [94:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [94:8]
+    |       |   |--TYPE -> TYPE [94:15]
+    |       |   |   |--IDENT -> Class [94:15]
+    |       |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [94:20]
+    |       |   |   |   |--GENERIC_START -> < [94:20]
+    |       |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [94:21]
+    |       |   |   |   |   `--WILDCARD_TYPE -> ? [94:21]
+    |       |   |   |   `--GENERIC_END -> > [94:22]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [94:23]
+    |       |   |       `--RBRACK -> ] [94:24]
+    |       |   |--IDENT -> getMethodArguments [94:26]
+    |       |   |--LPAREN -> ( [94:44]
+    |       |   |--PARAMETERS -> PARAMETERS [94:45]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [94:45]
+    |       |   |       |--MODIFIERS -> MODIFIERS [94:45]
+    |       |   |       |--TYPE -> TYPE [94:45]
+    |       |   |       |   `--LITERAL_BOOLEAN -> boolean [94:45]
+    |       |   |       `--IDENT -> isFPType [94:53]
+    |       |   |--RPAREN -> ) [94:61]
+    |       |   `--SLIST -> { [94:63]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [95:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [95:12]
+    |       |       |   |--TYPE -> TYPE [95:12]
+    |       |       |   |   |--IDENT -> Class [95:12]
+    |       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [95:17]
+    |       |       |   |       |--GENERIC_START -> < [95:17]
+    |       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [95:18]
+    |       |       |   |       |   `--WILDCARD_TYPE -> ? [95:18]
+    |       |       |   |       `--GENERIC_END -> > [95:19]
+    |       |       |   |--IDENT -> N [95:21]
+    |       |       |   `--ASSIGN -> = [95:23]
+    |       |       |       `--EXPR -> EXPR [95:36]
+    |       |       |           `--QUESTION -> ? [95:36]
+    |       |       |               |--LPAREN -> ( [95:25]
+    |       |       |               |--IDENT -> isFPType [95:26]
+    |       |       |               |--RPAREN -> ) [95:34]
+    |       |       |               |--DOT -> . [95:43]
+    |       |       |               |   |--IDENT -> Float [95:38]
+    |       |       |               |   `--IDENT -> TYPE [95:44]
+    |       |       |               |--COLON -> : [95:49]
+    |       |       |               `--DOT -> . [95:58]
+    |       |       |                   |--IDENT -> Integer [95:51]
+    |       |       |                   `--IDENT -> TYPE [95:59]
+    |       |       |--SEMI -> ; [95:63]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [96:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [96:12]
+    |       |       |   |--TYPE -> TYPE [96:12]
+    |       |       |   |   |--IDENT -> Class [96:12]
+    |       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [96:17]
+    |       |       |   |       |--GENERIC_START -> < [96:17]
+    |       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [96:18]
+    |       |       |   |       |   `--WILDCARD_TYPE -> ? [96:18]
+    |       |       |   |       `--GENERIC_END -> > [96:19]
+    |       |       |   |--IDENT -> G [96:21]
+    |       |       |   `--ASSIGN -> = [96:23]
+    |       |       |       `--EXPR -> EXPR [96:36]
+    |       |       |           `--QUESTION -> ? [96:36]
+    |       |       |               |--LPAREN -> ( [96:25]
+    |       |       |               |--IDENT -> isFPType [96:26]
+    |       |       |               |--RPAREN -> ) [96:34]
+    |       |       |               |--DOT -> . [96:48]
+    |       |       |               |   |--IDENT -> Graphics2D [96:38]
+    |       |       |               |   `--LITERAL_CLASS -> class [96:49]
+    |       |       |               |--COLON -> : [96:55]
+    |       |       |               `--DOT -> . [96:65]
+    |       |       |                   |--IDENT -> Graphics [96:57]
+    |       |       |                   `--LITERAL_CLASS -> class [96:66]
+    |       |       |--SEMI -> ; [96:71]
+    |       |       |--LITERAL_SWITCH -> switch [97:12]
+    |       |       |   |--LPAREN -> ( [97:19]
+    |       |       |   |--EXPR -> EXPR [97:20]
+    |       |       |   |   `--LITERAL_THIS -> this [97:20]
+    |       |       |   |--RPAREN -> ) [97:24]
+    |       |       |   |--LCURLY -> { [97:26]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [98:16]
+    |       |       |   |   |--LITERAL_CASE -> case [98:16]
+    |       |       |   |   |   |--EXPR -> EXPR [98:21]
+    |       |       |   |   |   |   `--IDENT -> IGNN [98:21]
+    |       |       |   |   |   `--COLON -> : [98:25]
+    |       |       |   |   `--SLIST -> SLIST [99:20]
+    |       |       |   |       `--LITERAL_RETURN -> return [99:20]
+    |       |       |   |           |--EXPR -> EXPR [99:27]
+    |       |       |   |           |   `--LITERAL_NEW -> new [99:27]
+    |       |       |   |           |       |--IDENT -> Class [99:31]
+    |       |       |   |           |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [99:36]
+    |       |       |   |           |       |   |--GENERIC_START -> < [99:36]
+    |       |       |   |           |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [99:37]
+    |       |       |   |           |       |   |   `--WILDCARD_TYPE -> ? [99:37]
+    |       |       |   |           |       |   `--GENERIC_END -> > [99:38]
+    |       |       |   |           |       |--ARRAY_DECLARATOR -> [ [99:39]
+    |       |       |   |           |       |   `--RBRACK -> ] [99:40]
+    |       |       |   |           |       `--ARRAY_INIT -> { [99:41]
+    |       |       |   |           |           |--EXPR -> EXPR [99:49]
+    |       |       |   |           |           |   `--DOT -> . [99:49]
+    |       |       |   |           |           |       |--IDENT -> Integer [99:42]
+    |       |       |   |           |           |       `--IDENT -> TYPE [99:50]
+    |       |       |   |           |           |--COMMA -> , [99:54]
+    |       |       |   |           |           |--EXPR -> EXPR [99:56]
+    |       |       |   |           |           |   `--IDENT -> G [99:56]
+    |       |       |   |           |           |--COMMA -> , [99:57]
+    |       |       |   |           |           |--EXPR -> EXPR [99:59]
+    |       |       |   |           |           |   `--IDENT -> N [99:59]
+    |       |       |   |           |           |--COMMA -> , [99:60]
+    |       |       |   |           |           |--EXPR -> EXPR [99:62]
+    |       |       |   |           |           |   `--IDENT -> N [99:62]
+    |       |       |   |           |           `--RCURLY -> } [99:63]
+    |       |       |   |           `--SEMI -> ; [99:64]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [100:16]
+    |       |       |   |   |--LITERAL_CASE -> case [100:16]
+    |       |       |   |   |   |--EXPR -> EXPR [100:21]
+    |       |       |   |   |   |   `--IDENT -> IIGNN [100:21]
+    |       |       |   |   |   `--COLON -> : [100:26]
+    |       |       |   |   `--SLIST -> SLIST [101:20]
+    |       |       |   |       `--LITERAL_RETURN -> return [101:20]
+    |       |       |   |           |--EXPR -> EXPR [101:27]
+    |       |       |   |           |   `--LITERAL_NEW -> new [101:27]
+    |       |       |   |           |       |--IDENT -> Class [101:31]
+    |       |       |   |           |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [101:36]
+    |       |       |   |           |       |   |--GENERIC_START -> < [101:36]
+    |       |       |   |           |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [101:37]
+    |       |       |   |           |       |   |   `--WILDCARD_TYPE -> ? [101:37]
+    |       |       |   |           |       |   `--GENERIC_END -> > [101:38]
+    |       |       |   |           |       |--ARRAY_DECLARATOR -> [ [101:39]
+    |       |       |   |           |       |   `--RBRACK -> ] [101:40]
+    |       |       |   |           |       `--ARRAY_INIT -> { [101:41]
+    |       |       |   |           |           |--EXPR -> EXPR [101:49]
+    |       |       |   |           |           |   `--DOT -> . [101:49]
+    |       |       |   |           |           |       |--IDENT -> Integer [101:42]
+    |       |       |   |           |           |       `--IDENT -> TYPE [101:50]
+    |       |       |   |           |           |--COMMA -> , [101:54]
+    |       |       |   |           |           |--EXPR -> EXPR [101:63]
+    |       |       |   |           |           |   `--DOT -> . [101:63]
+    |       |       |   |           |           |       |--IDENT -> Integer [101:56]
+    |       |       |   |           |           |       `--IDENT -> TYPE [101:64]
+    |       |       |   |           |           |--COMMA -> , [101:68]
+    |       |       |   |           |           |--EXPR -> EXPR [101:70]
+    |       |       |   |           |           |   `--IDENT -> G [101:70]
+    |       |       |   |           |           |--COMMA -> , [101:71]
+    |       |       |   |           |           |--EXPR -> EXPR [101:73]
+    |       |       |   |           |           |   `--IDENT -> N [101:73]
+    |       |       |   |           |           |--COMMA -> , [101:74]
+    |       |       |   |           |           |--EXPR -> EXPR [101:76]
+    |       |       |   |           |           |   `--IDENT -> N [101:76]
+    |       |       |   |           |           `--RCURLY -> } [101:77]
+    |       |       |   |           `--SEMI -> ; [101:78]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [102:16]
+    |       |       |   |   |--LITERAL_CASE -> case [102:16]
+    |       |       |   |   |   |--EXPR -> EXPR [102:21]
+    |       |       |   |   |   |   `--IDENT -> GNNII [102:21]
+    |       |       |   |   |   `--COLON -> : [102:26]
+    |       |       |   |   `--SLIST -> SLIST [103:20]
+    |       |       |   |       `--LITERAL_RETURN -> return [103:20]
+    |       |       |   |           |--EXPR -> EXPR [103:27]
+    |       |       |   |           |   `--LITERAL_NEW -> new [103:27]
+    |       |       |   |           |       |--IDENT -> Class [103:31]
+    |       |       |   |           |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [103:36]
+    |       |       |   |           |       |   |--GENERIC_START -> < [103:36]
+    |       |       |   |           |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [103:37]
+    |       |       |   |           |       |   |   `--WILDCARD_TYPE -> ? [103:37]
+    |       |       |   |           |       |   `--GENERIC_END -> > [103:38]
+    |       |       |   |           |       |--ARRAY_DECLARATOR -> [ [103:39]
+    |       |       |   |           |       |   `--RBRACK -> ] [103:40]
+    |       |       |   |           |       `--ARRAY_INIT -> { [103:41]
+    |       |       |   |           |           |--EXPR -> EXPR [103:42]
+    |       |       |   |           |           |   `--IDENT -> G [103:42]
+    |       |       |   |           |           |--COMMA -> , [103:43]
+    |       |       |   |           |           |--EXPR -> EXPR [103:45]
+    |       |       |   |           |           |   `--IDENT -> N [103:45]
+    |       |       |   |           |           |--COMMA -> , [103:46]
+    |       |       |   |           |           |--EXPR -> EXPR [103:48]
+    |       |       |   |           |           |   `--IDENT -> N [103:48]
+    |       |       |   |           |           |--COMMA -> , [103:49]
+    |       |       |   |           |           |--EXPR -> EXPR [103:58]
+    |       |       |   |           |           |   `--DOT -> . [103:58]
+    |       |       |   |           |           |       |--IDENT -> Integer [103:51]
+    |       |       |   |           |           |       `--IDENT -> TYPE [103:59]
+    |       |       |   |           |           |--COMMA -> , [103:63]
+    |       |       |   |           |           |--EXPR -> EXPR [103:72]
+    |       |       |   |           |           |   `--DOT -> . [103:72]
+    |       |       |   |           |           |       |--IDENT -> Integer [103:65]
+    |       |       |   |           |           |       `--IDENT -> TYPE [103:73]
+    |       |       |   |           |           `--RCURLY -> } [103:77]
+    |       |       |   |           `--SEMI -> ; [103:78]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [104:16]
+    |       |       |   |   |--LITERAL_CASE -> case [104:16]
+    |       |       |   |   |   |--EXPR -> EXPR [104:21]
+    |       |       |   |   |   |   `--IDENT -> GNNC [104:21]
+    |       |       |   |   |   `--COLON -> : [104:25]
+    |       |       |   |   `--SLIST -> SLIST [105:20]
+    |       |       |   |       `--LITERAL_RETURN -> return [105:20]
+    |       |       |   |           |--EXPR -> EXPR [105:27]
+    |       |       |   |           |   `--LITERAL_NEW -> new [105:27]
+    |       |       |   |           |       |--IDENT -> Class [105:31]
+    |       |       |   |           |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [105:36]
+    |       |       |   |           |       |   |--GENERIC_START -> < [105:36]
+    |       |       |   |           |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [105:37]
+    |       |       |   |           |       |   |   `--WILDCARD_TYPE -> ? [105:37]
+    |       |       |   |           |       |   `--GENERIC_END -> > [105:38]
+    |       |       |   |           |       |--ARRAY_DECLARATOR -> [ [105:39]
+    |       |       |   |           |       |   `--RBRACK -> ] [105:40]
+    |       |       |   |           |       `--ARRAY_INIT -> { [105:41]
+    |       |       |   |           |           |--EXPR -> EXPR [105:42]
+    |       |       |   |           |           |   `--IDENT -> G [105:42]
+    |       |       |   |           |           |--COMMA -> , [105:43]
+    |       |       |   |           |           |--EXPR -> EXPR [105:45]
+    |       |       |   |           |           |   `--IDENT -> N [105:45]
+    |       |       |   |           |           |--COMMA -> , [105:46]
+    |       |       |   |           |           |--EXPR -> EXPR [105:48]
+    |       |       |   |           |           |   `--IDENT -> N [105:48]
+    |       |       |   |           |           |--COMMA -> , [105:49]
+    |       |       |   |           |           |--EXPR -> EXPR [105:60]
+    |       |       |   |           |           |   `--DOT -> . [105:60]
+    |       |       |   |           |           |       |--IDENT -> Character [105:51]
+    |       |       |   |           |           |       `--IDENT -> TYPE [105:61]
+    |       |       |   |           |           `--RCURLY -> } [105:65]
+    |       |       |   |           `--SEMI -> ; [105:66]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [106:16]
+    |       |       |   |   |--LITERAL_DEFAULT -> default [106:16]
+    |       |       |   |   |   `--COLON -> : [106:23]
+    |       |       |   |   `--SLIST -> SLIST [107:20]
+    |       |       |   |       `--LITERAL_THROW -> throw [107:20]
+    |       |       |   |           |--EXPR -> EXPR [107:26]
+    |       |       |   |           |   `--LITERAL_NEW -> new [107:26]
+    |       |       |   |           |       |--IDENT -> RuntimeException [107:30]
+    |       |       |   |           |       |--LPAREN -> ( [107:46]
+    |       |       |   |           |       |--ELIST -> ELIST [107:47]
+    |       |       |   |           |       |   `--EXPR -> EXPR [107:47]
+    |       |       |   |           |       |       `--STRING_LITERAL -> "Unknown method arguments!" [107:47]
+    |       |       |   |           |       `--RPAREN -> ) [107:74]
+    |       |       |   |           `--SEMI -> ; [107:75]
+    |       |       |   `--RCURLY -> } [108:12]
+    |       |       `--RCURLY -> } [109:8]
+    |       `--RCURLY -> } [110:4]
+    |--CLASS_DEF -> CLASS_DEF [112:4]
+    |   |--MODIFIERS -> MODIFIERS [112:4]
+    |   |   |--LITERAL_PUBLIC -> public [112:4]
+    |   |   `--LITERAL_STATIC -> static [112:11]
+    |   |--LITERAL_CLASS -> class [112:18]
+    |   |--IDENT -> IntData [112:24]
+    |   `--OBJBLOCK -> OBJBLOCK [112:32]
+    |       |--LCURLY -> { [112:32]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [113:8]
+    |       |   |--MODIFIERS -> MODIFIERS [113:8]
+    |       |   |--TYPE -> TYPE [113:8]
+    |       |   |   |--LITERAL_INT -> int [113:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [113:11]
+    |       |   |       `--RBRACK -> ] [113:12]
+    |       |   |--IDENT -> xorData [113:14]
+    |       |   `--SEMI -> ; [113:21]
+    |       |--CTOR_DEF -> CTOR_DEF [115:8]
+    |       |   |--MODIFIERS -> MODIFIERS [115:8]
+    |       |   |--IDENT -> IntData [115:8]
+    |       |   |--LPAREN -> ( [115:15]
+    |       |   |--PARAMETERS -> PARAMETERS [115:16]
+    |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [115:16]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [115:16]
+    |       |   |   |   |--TYPE -> TYPE [115:16]
+    |       |   |   |   |   `--IDENT -> Object [115:16]
+    |       |   |   |   `--IDENT -> srcPixel [115:23]
+    |       |   |   |--COMMA -> , [115:31]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [115:33]
+    |       |   |       |--MODIFIERS -> MODIFIERS [115:33]
+    |       |   |       |--TYPE -> TYPE [115:33]
+    |       |   |       |   `--IDENT -> Object [115:33]
+    |       |   |       `--IDENT -> xorPixel [115:40]
+    |       |   |--RPAREN -> ) [115:48]
+    |       |   `--SLIST -> { [115:50]
+    |       |       |--EXPR -> EXPR [116:25]
+    |       |       |   `--ASSIGN -> = [116:25]
+    |       |       |       |--DOT -> . [116:16]
+    |       |       |       |   |--LITERAL_THIS -> this [116:12]
+    |       |       |       |   `--IDENT -> xorData [116:17]
+    |       |       |       `--TYPECAST -> ( [116:27]
+    |       |       |           |--TYPE -> TYPE [116:28]
+    |       |       |           |   |--LITERAL_INT -> int [116:28]
+    |       |       |           |   `--ARRAY_DECLARATOR -> [ [116:31]
+    |       |       |           |       `--RBRACK -> ] [116:32]
+    |       |       |           |--RPAREN -> ) [116:33]
+    |       |       |           `--IDENT -> srcPixel [116:35]
+    |       |       |--SEMI -> ; [116:43]
+    |       |       |--EXPR -> EXPR [117:25]
+    |       |       |   `--ASSIGN -> = [117:25]
+    |       |       |       |--DOT -> . [117:16]
+    |       |       |       |   |--LITERAL_THIS -> this [117:12]
+    |       |       |       |   `--IDENT -> xorData [117:17]
+    |       |       |       `--TYPECAST -> ( [117:27]
+    |       |       |           |--TYPE -> TYPE [117:28]
+    |       |       |           |   |--LITERAL_INT -> int [117:28]
+    |       |       |           |   `--ARRAY_DECLARATOR -> [ [117:31]
+    |       |       |           |       `--RBRACK -> ] [117:32]
+    |       |       |           |--RPAREN -> ) [117:33]
+    |       |       |           `--IDENT -> xorPixel [117:35]
+    |       |       |--SEMI -> ; [117:43]
+    |       |       `--RCURLY -> } [118:8]
+    |       |--METHOD_DEF -> METHOD_DEF [120:8]
+    |       |   |--MODIFIERS -> MODIFIERS [120:8]
+    |       |   |   `--LITERAL_PROTECTED -> protected [120:8]
+    |       |   |--TYPE -> TYPE [120:18]
+    |       |   |   `--LITERAL_VOID -> void [120:18]
+    |       |   |--IDENT -> xorPixel [120:23]
+    |       |   |--LPAREN -> ( [120:31]
+    |       |   |--PARAMETERS -> PARAMETERS [120:32]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [120:32]
+    |       |   |       |--MODIFIERS -> MODIFIERS [120:32]
+    |       |   |       |--TYPE -> TYPE [120:32]
+    |       |   |       |   `--IDENT -> Object [120:32]
+    |       |   |       `--IDENT -> pixData [120:39]
+    |       |   |--RPAREN -> ) [120:46]
+    |       |   `--SLIST -> { [120:48]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [121:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [121:12]
+    |       |       |   |--TYPE -> TYPE [121:12]
+    |       |       |   |   |--LITERAL_INT -> int [121:12]
+    |       |       |   |   `--ARRAY_DECLARATOR -> [ [121:15]
+    |       |       |   |       `--RBRACK -> ] [121:16]
+    |       |       |   |--IDENT -> dstData [121:18]
+    |       |       |   `--ASSIGN -> = [121:26]
+    |       |       |       `--EXPR -> EXPR [121:28]
+    |       |       |           `--TYPECAST -> ( [121:28]
+    |       |       |               |--TYPE -> TYPE [121:29]
+    |       |       |               |   |--LITERAL_INT -> int [121:29]
+    |       |       |               |   `--ARRAY_DECLARATOR -> [ [121:32]
+    |       |       |               |       `--RBRACK -> ] [121:33]
+    |       |       |               |--RPAREN -> ) [121:34]
+    |       |       |               `--IDENT -> pixData [121:36]
+    |       |       |--SEMI -> ; [121:43]
+    |       |       |--LITERAL_FOR -> for [122:12]
+    |       |       |   |--LPAREN -> ( [122:16]
+    |       |       |   |--FOR_INIT -> FOR_INIT [122:17]
+    |       |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [122:17]
+    |       |       |   |       |--MODIFIERS -> MODIFIERS [122:17]
+    |       |       |   |       |--TYPE -> TYPE [122:17]
+    |       |       |   |       |   `--LITERAL_INT -> int [122:17]
+    |       |       |   |       |--IDENT -> i [122:21]
+    |       |       |   |       `--ASSIGN -> = [122:23]
+    |       |       |   |           `--EXPR -> EXPR [122:25]
+    |       |       |   |               `--NUM_INT -> 0 [122:25]
+    |       |       |   |--SEMI -> ; [122:26]
+    |       |       |   |--FOR_CONDITION -> FOR_CONDITION [122:30]
+    |       |       |   |   `--EXPR -> EXPR [122:30]
+    |       |       |   |       `--LT -> < [122:30]
+    |       |       |   |           |--IDENT -> i [122:28]
+    |       |       |   |           `--DOT -> . [122:39]
+    |       |       |   |               |--IDENT -> dstData [122:32]
+    |       |       |   |               `--IDENT -> length [122:40]
+    |       |       |   |--SEMI -> ; [122:46]
+    |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [122:49]
+    |       |       |   |   `--ELIST -> ELIST [122:49]
+    |       |       |   |       `--EXPR -> EXPR [122:49]
+    |       |       |   |           `--POST_INC -> ++ [122:49]
+    |       |       |   |               `--IDENT -> i [122:48]
+    |       |       |   |--RPAREN -> ) [122:51]
+    |       |       |   `--SLIST -> { [122:53]
+    |       |       |       |--EXPR -> EXPR [123:27]
+    |       |       |       |   `--BXOR_ASSIGN -> ^= [123:27]
+    |       |       |       |       |--INDEX_OP -> [ [123:23]
+    |       |       |       |       |   |--IDENT -> dstData [123:16]
+    |       |       |       |       |   |--EXPR -> EXPR [123:24]
+    |       |       |       |       |   |   `--IDENT -> i [123:24]
+    |       |       |       |       |   `--RBRACK -> ] [123:25]
+    |       |       |       |       `--INDEX_OP -> [ [123:37]
+    |       |       |       |           |--IDENT -> xorData [123:30]
+    |       |       |       |           |--EXPR -> EXPR [123:38]
+    |       |       |       |           |   `--IDENT -> i [123:38]
+    |       |       |       |           `--RBRACK -> ] [123:39]
+    |       |       |       |--SEMI -> ; [123:40]
+    |       |       |       `--RCURLY -> } [124:12]
+    |       |       `--RCURLY -> } [125:8]
+    |       |--METHOD_DEF -> METHOD_DEF [127:8]
+    |       |   |--MODIFIERS -> MODIFIERS [127:8]
+    |       |   |--TYPE -> TYPE [127:8]
+    |       |   |   |--IDENT -> Object [127:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [127:14]
+    |       |   |       `--RBRACK -> ] [127:15]
+    |       |   |--IDENT -> getXorData [127:17]
+    |       |   |--LPAREN -> ( [127:27]
+    |       |   |--PARAMETERS -> PARAMETERS [127:28]
+    |       |   |--RPAREN -> ) [127:28]
+    |       |   `--SLIST -> { [127:30]
+    |       |       |--LITERAL_RETURN -> return [128:12]
+    |       |       |   |--EXPR -> EXPR [128:19]
+    |       |       |   |   `--LITERAL_NEW -> new [128:19]
+    |       |       |   |       |--IDENT -> Object [128:23]
+    |       |       |   |       `--ARRAY_DECLARATOR -> [ [128:29]
+    |       |       |   |           |--EXPR -> EXPR [128:30]
+    |       |       |   |           |   `--NUM_INT -> 5 [128:30]
+    |       |       |   |           `--RBRACK -> ] [128:31]
+    |       |       |   `--SEMI -> ; [128:32]
+    |       |       `--RCURLY -> } [129:8]
+    |       |--METHOD_DEF -> METHOD_DEF [131:8]
+    |       |   |--MODIFIERS -> MODIFIERS [131:8]
+    |       |   |--TYPE -> TYPE [131:8]
+    |       |   |   `--LITERAL_VOID -> void [131:8]
+    |       |   |--IDENT -> method6 [131:13]
+    |       |   |--LPAREN -> ( [131:20]
+    |       |   |--PARAMETERS -> PARAMETERS [131:21]
+    |       |   |--RPAREN -> ) [131:21]
+    |       |   `--SLIST -> { [131:23]
+    |       |       |--LITERAL_IF -> if [132:12]
+    |       |       |   |--LPAREN -> ( [132:15]
+    |       |       |   |--EXPR -> EXPR [134:20]
+    |       |       |   |   `--LOR -> || [134:20]
+    |       |       |   |       |--LAND -> && [133:20]
+    |       |       |   |       |   |--EQUAL -> == [132:36]
+    |       |       |   |       |   |   |--DOT -> . [132:28]
+    |       |       |   |       |   |   |   |--METHOD_CALL -> ( [132:26]
+    |       |       |   |       |   |   |   |   |--IDENT -> getXorData [132:16]
+    |       |       |   |       |   |   |   |   |--ELIST -> ELIST [132:27]
+    |       |       |   |       |   |   |   |   `--RPAREN -> ) [132:27]
+    |       |       |   |       |   |   |   `--IDENT -> length [132:29]
+    |       |       |   |       |   |   `--NUM_INT -> 5 [132:39]
+    |       |       |   |       |   `--NOT_EQUAL -> != [133:44]
+    |       |       |   |       |       |--INDEX_OP -> [ [133:40]
+    |       |       |   |       |       |   |--METHOD_CALL -> ( [133:38]
+    |       |       |   |       |       |   |   |--DOT -> . [133:27]
+    |       |       |   |       |       |   |   |   |--LITERAL_THIS -> this [133:23]
+    |       |       |   |       |       |   |   |   `--IDENT -> getXorData [133:28]
+    |       |       |   |       |       |   |   |--ELIST -> ELIST [133:39]
+    |       |       |   |       |       |   |   `--RPAREN -> ) [133:39]
+    |       |       |   |       |       |   |--EXPR -> EXPR [133:41]
+    |       |       |   |       |       |   |   `--NUM_INT -> 1 [133:41]
+    |       |       |   |       |       |   `--RBRACK -> ] [133:42]
+    |       |       |   |       |       `--DOT -> . [133:54]
+    |       |       |   |       |           |--IDENT -> IntData [133:47]
+    |       |       |   |       |           `--LITERAL_CLASS -> class [133:55]
+    |       |       |   |       `--NOT_EQUAL -> != [134:44]
+    |       |       |   |           |--INDEX_OP -> [ [134:40]
+    |       |       |   |           |   |--METHOD_CALL -> ( [134:38]
+    |       |       |   |           |   |   |--DOT -> . [134:27]
+    |       |       |   |           |   |   |   |--LITERAL_THIS -> this [134:23]
+    |       |       |   |           |   |   |   `--IDENT -> getXorData [134:28]
+    |       |       |   |           |   |   |--ELIST -> ELIST [134:39]
+    |       |       |   |           |   |   `--RPAREN -> ) [134:39]
+    |       |       |   |           |   |--EXPR -> EXPR [134:41]
+    |       |       |   |           |   |   `--NUM_INT -> 5 [134:41]
+    |       |       |   |           |   `--RBRACK -> ] [134:42]
+    |       |       |   |           `--DOT -> . [134:54]
+    |       |       |   |               |--IDENT -> IntData [134:47]
+    |       |       |   |               `--LITERAL_CLASS -> class [134:55]
+    |       |       |   |--RPAREN -> ) [134:60]
+    |       |       |   `--SLIST -> { [134:62]
+    |       |       |       |--EXPR -> EXPR [135:34]
+    |       |       |       |   `--METHOD_CALL -> ( [135:34]
+    |       |       |       |       |--DOT -> . [135:26]
+    |       |       |       |       |   |--DOT -> . [135:22]
+    |       |       |       |       |   |   |--IDENT -> System [135:16]
+    |       |       |       |       |   |   `--IDENT -> out [135:23]
+    |       |       |       |       |   `--IDENT -> println [135:27]
+    |       |       |       |       |--ELIST -> ELIST [135:47]
+    |       |       |       |       |   `--EXPR -> EXPR [135:47]
+    |       |       |       |       |       `--DOT -> . [135:47]
+    |       |       |       |       |           |--METHOD_CALL -> ( [135:45]
+    |       |       |       |       |           |   |--IDENT -> getXorData [135:35]
+    |       |       |       |       |           |   |--ELIST -> ELIST [135:46]
+    |       |       |       |       |           |   `--RPAREN -> ) [135:46]
+    |       |       |       |       |           `--IDENT -> length [135:48]
+    |       |       |       |       `--RPAREN -> ) [135:54]
+    |       |       |       |--SEMI -> ; [135:55]
+    |       |       |       `--RCURLY -> } [136:12]
+    |       |       `--RCURLY -> } [137:8]
+    |       `--RCURLY -> } [139:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [140:4]
+    |   |--MODIFIERS -> MODIFIERS [140:4]
+    |   |   `--LITERAL_PROTECTED -> protected [140:4]
+    |   |--TYPE -> TYPE [140:14]
+    |   |   |--IDENT -> TreeSet [140:14]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [140:21]
+    |   |       |--GENERIC_START -> < [140:21]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [140:22]
+    |   |       |   |--LITERAL_BYTE -> byte [140:22]
+    |   |       |   `--ARRAY_DECLARATOR -> [ [140:27]
+    |   |       |       `--RBRACK -> ] [140:28]
+    |   |       `--GENERIC_END -> > [140:29]
+    |   |--IDENT -> sortedPrefixes [140:31]
+    |   |--ASSIGN -> = [140:46]
+    |   |   `--EXPR -> EXPR [140:61]
+    |   |       `--METHOD_CALL -> ( [140:61]
+    |   |           |--IDENT -> createTreeSet [140:48]
+    |   |           |--ELIST -> ELIST [140:62]
+    |   |           `--RPAREN -> ) [140:62]
+    |   `--SEMI -> ; [140:63]
+    |--METHOD_DEF -> METHOD_DEF [142:4]
+    |   |--MODIFIERS -> MODIFIERS [142:4]
+    |   |--TYPE -> TYPE [142:4]
+    |   |   |--IDENT -> TreeSet [142:4]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [142:11]
+    |   |       |--GENERIC_START -> < [142:11]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [142:12]
+    |   |       |   |--LITERAL_BYTE -> byte [142:12]
+    |   |       |   `--ARRAY_DECLARATOR -> [ [142:16]
+    |   |       |       `--RBRACK -> ] [142:17]
+    |   |       `--GENERIC_END -> > [142:18]
+    |   |--IDENT -> createTreeSet [142:20]
+    |   |--LPAREN -> ( [142:33]
+    |   |--PARAMETERS -> PARAMETERS [142:34]
+    |   |--RPAREN -> ) [142:34]
+    |   `--SLIST -> { [142:36]
+    |       |--LITERAL_RETURN -> return [143:8]
+    |       |   |--EXPR -> EXPR [143:15]
+    |       |   |   `--LITERAL_NULL -> null [143:15]
+    |       |   `--SEMI -> ; [143:19]
+    |       `--RCURLY -> } [144:4]
+    |--METHOD_DEF -> METHOD_DEF [146:4]
+    |   |--MODIFIERS -> MODIFIERS [146:4]
+    |   |   `--LITERAL_PUBLIC -> public [146:4]
+    |   |--TYPE -> TYPE [146:11]
+    |   |   `--IDENT -> Object [146:11]
+    |   |--IDENT -> newInstance [146:18]
+    |   |--LPAREN -> ( [146:29]
+    |   |--PARAMETERS -> PARAMETERS [146:30]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [146:30]
+    |   |       |--MODIFIERS -> MODIFIERS [146:30]
+    |   |       |--TYPE -> TYPE [146:30]
+    |   |       |   |--IDENT -> Object [146:30]
+    |   |       |   `--ARRAY_DECLARATOR -> [ [146:36]
+    |   |       |       `--RBRACK -> ] [146:37]
+    |   |       `--IDENT -> objects [146:39]
+    |   |--RPAREN -> ) [146:46]
+    |   `--SLIST -> { [146:47]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [148:8]
+    |       |   |--MODIFIERS -> MODIFIERS [148:8]
+    |       |   |--TYPE -> TYPE [148:8]
+    |       |   |   `--IDENT -> InputAntlr4AstRegressionNewTypeTree [148:8]
+    |       |   |--IDENT -> tmpConstructor [148:44]
+    |       |   `--ASSIGN -> = [148:59]
+    |       |       `--EXPR -> EXPR [148:61]
+    |       |           `--LITERAL_NULL -> null [148:61]
+    |       |--SEMI -> ; [148:65]
+    |       |--LITERAL_RETURN -> return [149:8]
+    |       |   |--EXPR -> EXPR [149:41]
+    |       |   |   `--METHOD_CALL -> ( [149:41]
+    |       |   |       |--DOT -> . [149:29]
+    |       |   |       |   |--IDENT -> tmpConstructor [149:15]
+    |       |   |       |   `--IDENT -> newInstance [149:30]
+    |       |   |       |--ELIST -> ELIST [149:42]
+    |       |   |       |   `--EXPR -> EXPR [149:42]
+    |       |   |       |       `--TYPECAST -> ( [149:42]
+    |       |   |       |           |--TYPE -> TYPE [149:43]
+    |       |   |       |           |   |--IDENT -> Object [149:43]
+    |       |   |       |           |   `--ARRAY_DECLARATOR -> [ [149:49]
+    |       |   |       |           |       `--RBRACK -> ] [149:50]
+    |       |   |       |           |--RPAREN -> ) [149:51]
+    |       |   |       |           `--LITERAL_NULL -> null [149:52]
+    |       |   |       `--RPAREN -> ) [149:56]
+    |       |   `--SEMI -> ; [149:57]
+    |       `--RCURLY -> } [150:4]
+    |--METHOD_DEF -> METHOD_DEF [152:4]
+    |   |--MODIFIERS -> MODIFIERS [152:4]
+    |   |   `--LITERAL_PUBLIC -> public [152:4]
+    |   |--TYPE -> TYPE [152:11]
+    |   |   |--IDENT -> TypeVariable [152:11]
+    |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [152:23]
+    |   |   |   |--GENERIC_START -> < [152:23]
+    |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [152:24]
+    |   |   |   |   |--IDENT -> Class [152:24]
+    |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [152:29]
+    |   |   |   |       |--GENERIC_START -> < [152:29]
+    |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [152:30]
+    |   |   |   |       |   `--IDENT -> String [152:30]
+    |   |   |   |       `--GENERIC_END -> > [152:36]
+    |   |   |   `--GENERIC_END -> > [152:37]
+    |   |   `--ARRAY_DECLARATOR -> [ [152:38]
+    |   |       `--RBRACK -> ] [152:39]
+    |   |--IDENT -> getTypeParameters [152:41]
+    |   |--LPAREN -> ( [152:58]
+    |   |--PARAMETERS -> PARAMETERS [152:59]
+    |   |--RPAREN -> ) [152:59]
+    |   `--SLIST -> { [152:61]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [153:8]
+    |       |   |--MODIFIERS -> MODIFIERS [153:8]
+    |       |   |--TYPE -> TYPE [153:8]
+    |       |   |   `--IDENT -> ClassRepository [153:8]
+    |       |   |--IDENT -> info [153:24]
+    |       |   `--ASSIGN -> = [153:29]
+    |       |       `--EXPR -> EXPR [153:45]
+    |       |           `--METHOD_CALL -> ( [153:45]
+    |       |               |--IDENT -> getGenericInfo [153:31]
+    |       |               |--ELIST -> ELIST [153:46]
+    |       |               `--RPAREN -> ) [153:46]
+    |       |--SEMI -> ; [153:47]
+    |       |--LITERAL_IF -> if [154:8]
+    |       |   |--LPAREN -> ( [154:11]
+    |       |   |--EXPR -> EXPR [154:17]
+    |       |   |   `--NOT_EQUAL -> != [154:17]
+    |       |   |       |--IDENT -> info [154:12]
+    |       |   |       `--LITERAL_NULL -> null [154:20]
+    |       |   |--RPAREN -> ) [154:24]
+    |       |   |--LITERAL_RETURN -> return [155:12]
+    |       |   |   |--EXPR -> EXPR [155:19]
+    |       |   |   |   `--TYPECAST -> ( [155:19]
+    |       |   |   |       |--TYPE -> TYPE [155:20]
+    |       |   |   |       |   |--IDENT -> TypeVariable [155:20]
+    |       |   |   |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [155:32]
+    |       |   |   |       |   |   |--GENERIC_START -> < [155:32]
+    |       |   |   |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [155:33]
+    |       |   |   |       |   |   |   |--IDENT -> Class [155:33]
+    |       |   |   |       |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [155:38]
+    |       |   |   |       |   |   |       |--GENERIC_START -> < [155:38]
+    |       |   |   |       |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [155:39]
+    |       |   |   |       |   |   |       |   `--IDENT -> String [155:39]
+    |       |   |   |       |   |   |       `--GENERIC_END -> > [155:45]
+    |       |   |   |       |   |   `--GENERIC_END -> > [155:46]
+    |       |   |   |       |   `--ARRAY_DECLARATOR -> [ [155:47]
+    |       |   |   |       |       `--RBRACK -> ] [155:48]
+    |       |   |   |       |--RPAREN -> ) [155:49]
+    |       |   |   |       `--METHOD_CALL -> ( [155:72]
+    |       |   |   |           |--DOT -> . [155:54]
+    |       |   |   |           |   |--IDENT -> info [155:50]
+    |       |   |   |           |   `--IDENT -> getTypeParameters [155:55]
+    |       |   |   |           |--ELIST -> ELIST [155:73]
+    |       |   |   |           `--RPAREN -> ) [155:73]
+    |       |   |   `--SEMI -> ; [155:74]
+    |       |   `--LITERAL_ELSE -> else [156:8]
+    |       |       `--LITERAL_RETURN -> return [157:12]
+    |       |           |--EXPR -> EXPR [157:19]
+    |       |           |   `--TYPECAST -> ( [157:19]
+    |       |           |       |--TYPE -> TYPE [157:20]
+    |       |           |       |   |--IDENT -> TypeVariable [157:20]
+    |       |           |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [157:32]
+    |       |           |       |   |   |--GENERIC_START -> < [157:32]
+    |       |           |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [157:33]
+    |       |           |       |   |   |   |--IDENT -> Class [157:33]
+    |       |           |       |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [157:38]
+    |       |           |       |   |   |       |--GENERIC_START -> < [157:38]
+    |       |           |       |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [157:39]
+    |       |           |       |   |   |       |   `--IDENT -> String [157:39]
+    |       |           |       |   |   |       `--GENERIC_END -> > [157:45]
+    |       |           |       |   |   `--GENERIC_END -> > [157:46]
+    |       |           |       |   `--ARRAY_DECLARATOR -> [ [157:47]
+    |       |           |       |       `--RBRACK -> ] [157:48]
+    |       |           |       |--RPAREN -> ) [157:49]
+    |       |           |       `--LITERAL_NEW -> new [157:50]
+    |       |           |           |--IDENT -> TypeVariable [157:54]
+    |       |           |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [157:66]
+    |       |           |           |   |--GENERIC_START -> < [157:66]
+    |       |           |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [157:67]
+    |       |           |           |   |   `--WILDCARD_TYPE -> ? [157:67]
+    |       |           |           |   `--GENERIC_END -> > [157:68]
+    |       |           |           `--ARRAY_DECLARATOR -> [ [157:69]
+    |       |           |               |--EXPR -> EXPR [157:70]
+    |       |           |               |   `--NUM_INT -> 0 [157:70]
+    |       |           |               `--RBRACK -> ] [157:71]
+    |       |           `--SEMI -> ; [157:72]
+    |       `--RCURLY -> } [158:4]
+    |--CLASS_DEF -> CLASS_DEF [159:4]
+    |   |--MODIFIERS -> MODIFIERS [159:4]
+    |   |--LITERAL_CLASS -> class [159:4]
+    |   |--IDENT -> ClassRepository [159:10]
+    |   `--OBJBLOCK -> OBJBLOCK [159:26]
+    |       |--LCURLY -> { [159:26]
+    |       |--METHOD_DEF -> METHOD_DEF [161:8]
+    |       |   |--MODIFIERS -> MODIFIERS [161:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [161:8]
+    |       |   |--TYPE -> TYPE [161:15]
+    |       |   |   `--IDENT -> Object [161:15]
+    |       |   |--IDENT -> getTypeParameters [161:22]
+    |       |   |--LPAREN -> ( [161:39]
+    |       |   |--PARAMETERS -> PARAMETERS [161:40]
+    |       |   |--RPAREN -> ) [161:40]
+    |       |   `--SLIST -> { [161:42]
+    |       |       |--LITERAL_RETURN -> return [162:12]
+    |       |       |   |--EXPR -> EXPR [162:19]
+    |       |       |   |   `--LITERAL_NULL -> null [162:19]
+    |       |       |   `--SEMI -> ; [162:23]
+    |       |       `--RCURLY -> } [163:8]
+    |       `--RCURLY -> } [164:4]
+    |--CLASS_DEF -> CLASS_DEF [165:4]
+    |   |--MODIFIERS -> MODIFIERS [165:4]
+    |   |--LITERAL_CLASS -> class [165:4]
+    |   |--IDENT -> TypeVariable [165:10]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [165:22]
+    |   |   |--GENERIC_START -> < [165:22]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [165:23]
+    |   |   |   `--IDENT -> E [165:23]
+    |   |   `--GENERIC_END -> > [165:24]
+    |   `--OBJBLOCK -> OBJBLOCK [165:26]
+    |       |--LCURLY -> { [165:26]
+    |       `--RCURLY -> } [167:4]
+    |--METHOD_DEF -> METHOD_DEF [169:4]
+    |   |--MODIFIERS -> MODIFIERS [169:4]
+    |   |   `--LITERAL_PRIVATE -> private [169:4]
+    |   |--TYPE -> TYPE [169:12]
+    |   |   `--IDENT -> ClassRepository [169:12]
+    |   |--IDENT -> getGenericInfo [169:28]
+    |   |--LPAREN -> ( [169:42]
+    |   |--PARAMETERS -> PARAMETERS [169:43]
+    |   |--RPAREN -> ) [169:43]
+    |   `--SLIST -> { [169:45]
+    |       |--LITERAL_RETURN -> return [170:8]
+    |       |   |--EXPR -> EXPR [170:15]
+    |       |   |   `--LITERAL_NULL -> null [170:15]
+    |       |   `--SEMI -> ; [170:19]
+    |       `--RCURLY -> } [171:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [172:4]
+    |   |--MODIFIERS -> MODIFIERS [172:4]
+    |   |--TYPE -> TYPE [172:4]
+    |   |   |--IDENT -> String [172:4]
+    |   |   `--ARRAY_DECLARATOR -> [ [172:10]
+    |   |       `--RBRACK -> ] [172:11]
+    |   |--IDENT -> c [172:13]
+    |   `--SEMI -> ; [172:19]
+    |--COMMA -> , [172:14]
+    |--VARIABLE_DEF -> VARIABLE_DEF [172:4]
+    |   |--MODIFIERS -> MODIFIERS [172:4]
+    |   |--TYPE -> TYPE [172:4]
+    |   |   |--IDENT -> String [172:4]
+    |   |   |--ARRAY_DECLARATOR -> [ [172:10]
+    |   |   |   `--RBRACK -> ] [172:11]
+    |   |   `--ARRAY_DECLARATOR -> [ [172:17]
+    |   |       `--RBRACK -> ] [172:18]
+    |   `--IDENT -> d [172:16]
+    |--VARIABLE_DEF -> VARIABLE_DEF [173:4]
+    |   |--MODIFIERS -> MODIFIERS [173:4]
+    |   |--TYPE -> TYPE [173:4]
+    |   |   |--IDENT -> String [173:4]
+    |   |   `--ARRAY_DECLARATOR -> [ [173:11]
+    |   |       `--RBRACK -> ] [173:12]
+    |   |--IDENT -> e [173:14]
+    |   `--SEMI -> ; [173:21]
+    |--COMMA -> , [173:15]
+    |--VARIABLE_DEF -> VARIABLE_DEF [173:4]
+    |   |--MODIFIERS -> MODIFIERS [173:4]
+    |   |--TYPE -> TYPE [173:4]
+    |   |   |--IDENT -> String [173:4]
+    |   |   |--ARRAY_DECLARATOR -> [ [173:11]
+    |   |   |   `--RBRACK -> ] [173:12]
+    |   |   `--ARRAY_DECLARATOR -> [ [173:19]
+    |   |       `--RBRACK -> ] [173:20]
+    |   `--IDENT -> f [173:17]
+    |--ENUM_DEF -> ENUM_DEF [175:4]
+    |   |--MODIFIERS -> MODIFIERS [175:4]
+    |   |   `--LITERAL_PUBLIC -> public [175:4]
+    |   |--ENUM -> enum [175:11]
+    |   |--IDENT -> Stooge [175:16]
+    |   `--OBJBLOCK -> OBJBLOCK [175:23]
+    |       |--LCURLY -> { [175:23]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [176:8]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [176:8]
+    |       |   `--IDENT -> MOE [176:8]
+    |       |--COMMA -> , [176:11]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [176:13]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [176:13]
+    |       |   `--IDENT -> CURLY [176:13]
+    |       |--COMMA -> , [176:18]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [176:20]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [176:20]
+    |       |   `--IDENT -> LARRY [176:20]
+    |       |--COMMA -> , [176:25]
+    |       `--RCURLY -> } [177:4]
+    |--METHOD_DEF -> METHOD_DEF [178:4]
+    |   |--MODIFIERS -> MODIFIERS [178:4]
+    |   |   `--LITERAL_STATIC -> static [178:4]
+    |   |--TYPE -> TYPE [178:11]
+    |   |   `--LITERAL_VOID -> void [178:11]
+    |   |--IDENT -> checkArrayTypes1 [178:16]
+    |   |--LPAREN -> ( [178:32]
+    |   |--PARAMETERS -> PARAMETERS [178:33]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [178:33]
+    |   |   |   |--MODIFIERS -> MODIFIERS [178:33]
+    |   |   |   |--TYPE -> TYPE [178:33]
+    |   |   |   |   `--IDENT -> ArrayTypes [178:33]
+    |   |   |   `--IDENT -> at [178:44]
+    |   |   |--COMMA -> , [178:46]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [178:48]
+    |   |       |--MODIFIERS -> MODIFIERS [178:48]
+    |   |       |--TYPE -> TYPE [178:48]
+    |   |       |   `--IDENT -> AnnotatedElement [178:48]
+    |   |       `--IDENT -> e [178:65]
+    |   |--RPAREN -> ) [178:66]
+    |   `--SLIST -> { [178:68]
+    |       |--LITERAL_IF -> if [179:8]
+    |       |   |--LPAREN -> ( [179:11]
+    |       |   |--EXPR -> EXPR [179:12]
+    |       |   |   `--LNOT -> ! [179:12]
+    |       |   |       |--LPAREN -> ( [179:13]
+    |       |   |       |--LAND -> && [179:43]
+    |       |   |       |   |--EQUAL -> == [179:27]
+    |       |   |       |   |   |--INDEX_OP -> [ [179:22]
+    |       |   |       |   |   |   |--METHOD_CALL -> ( [179:20]
+    |       |   |       |   |   |   |   |--DOT -> . [179:16]
+    |       |   |       |   |   |   |   |   |--IDENT -> at [179:14]
+    |       |   |       |   |   |   |   |   `--IDENT -> cls [179:17]
+    |       |   |       |   |   |   |   |--ELIST -> ELIST [179:21]
+    |       |   |       |   |   |   |   `--RPAREN -> ) [179:21]
+    |       |   |       |   |   |   |--EXPR -> EXPR [179:23]
+    |       |   |       |   |   |   |   `--NUM_INT -> 0 [179:23]
+    |       |   |       |   |   |   `--RBRACK -> ] [179:24]
+    |       |   |       |   |   `--DOT -> . [179:33]
+    |       |   |       |   |       |--IDENT -> Map [179:30]
+    |       |   |       |   |       `--LITERAL_CLASS -> class [179:34]
+    |       |   |       |   `--EQUAL -> == [180:27]
+    |       |   |       |       |--INDEX_OP -> [ [180:20]
+    |       |   |       |       |   |--METHOD_CALL -> ( [180:18]
+    |       |   |       |       |   |   |--DOT -> . [180:16]
+    |       |   |       |       |   |   |   |--IDENT -> at [180:14]
+    |       |   |       |       |   |   |   `--IDENT -> e [180:17]
+    |       |   |       |       |   |   |--ELIST -> ELIST [180:19]
+    |       |   |       |       |   |   `--RPAREN -> ) [180:19]
+    |       |   |       |       |   |--EXPR -> EXPR [180:21]
+    |       |   |       |       |   |   `--NUM_INT -> 0 [180:21]
+    |       |   |       |       |   `--RBRACK -> ] [180:22]
+    |       |   |       |       `--DOT -> . [180:36]
+    |       |   |       |           |--IDENT -> Stooge [180:30]
+    |       |   |       |           `--IDENT -> MOE [180:37]
+    |       |   |       `--RPAREN -> ) [180:42]
+    |       |   |--RPAREN -> ) [180:43]
+    |       |   `--SLIST -> { [180:45]
+    |       |       `--RCURLY -> } [182:8]
+    |       `--RCURLY -> } [183:4]
+    |--CLASS_DEF -> CLASS_DEF [185:4]
+    |   |--MODIFIERS -> MODIFIERS [185:4]
+    |   |   `--LITERAL_STATIC -> static [185:4]
+    |   |--LITERAL_CLASS -> class [185:11]
+    |   |--IDENT -> ArrayTypes [185:17]
+    |   `--OBJBLOCK -> OBJBLOCK [185:28]
+    |       |--LCURLY -> { [185:28]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [186:8]
+    |       |   |--MODIFIERS -> MODIFIERS [186:8]
+    |       |   |--TYPE -> TYPE [186:8]
+    |       |   |   |--IDENT -> Object [186:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [186:14]
+    |       |   |       `--RBRACK -> ] [186:15]
+    |       |   |--IDENT -> cls [186:17]
+    |       |   `--SEMI -> ; [186:20]
+    |       |--METHOD_DEF -> METHOD_DEF [188:8]
+    |       |   |--MODIFIERS -> MODIFIERS [188:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [188:8]
+    |       |   |--TYPE -> TYPE [188:15]
+    |       |   |   |--IDENT -> Stooge [188:15]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [188:21]
+    |       |   |       `--RBRACK -> ] [188:22]
+    |       |   |--IDENT -> e [188:24]
+    |       |   |--LPAREN -> ( [188:25]
+    |       |   |--PARAMETERS -> PARAMETERS [188:26]
+    |       |   |--RPAREN -> ) [188:26]
+    |       |   `--SLIST -> { [188:28]
+    |       |       |--LITERAL_RETURN -> return [189:12]
+    |       |       |   |--EXPR -> EXPR [189:19]
+    |       |       |   |   `--LITERAL_NULL -> null [189:19]
+    |       |       |   `--SEMI -> ; [189:23]
+    |       |       `--RCURLY -> } [190:8]
+    |       |--METHOD_DEF -> METHOD_DEF [194:8]
+    |       |   |--MODIFIERS -> MODIFIERS [194:8]
+    |       |   |--TYPE -> TYPE [194:8]
+    |       |   |   |--IDENT -> Object [194:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [194:14]
+    |       |   |       `--RBRACK -> ] [194:15]
+    |       |   |--IDENT -> cls [194:17]
+    |       |   |--LPAREN -> ( [194:20]
+    |       |   |--PARAMETERS -> PARAMETERS [194:21]
+    |       |   |--RPAREN -> ) [194:21]
+    |       |   `--SLIST -> { [194:23]
+    |       |       |--LITERAL_RETURN -> return [195:12]
+    |       |       |   |--EXPR -> EXPR [195:19]
+    |       |       |   |   `--IDENT -> cls [195:19]
+    |       |       |   `--SEMI -> ; [195:22]
+    |       |       `--RCURLY -> } [196:8]
+    |       |--METHOD_DEF -> METHOD_DEF [198:8]
+    |       |   |--MODIFIERS -> MODIFIERS [198:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [198:8]
+    |       |   |--TYPE -> TYPE [198:15]
+    |       |   |   |--LITERAL_INT -> int [198:15]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [198:18]
+    |       |   |       `--RBRACK -> ] [198:19]
+    |       |   |--IDENT -> a [198:21]
+    |       |   |--LPAREN -> ( [198:22]
+    |       |   |--PARAMETERS -> PARAMETERS [198:23]
+    |       |   |--RPAREN -> ) [198:23]
+    |       |   `--SLIST -> { [198:25]
+    |       |       |--LITERAL_RETURN -> return [199:12]
+    |       |       |   |--EXPR -> EXPR [199:19]
+    |       |       |   |   `--LITERAL_NULL -> null [199:19]
+    |       |       |   `--SEMI -> ; [199:23]
+    |       |       `--RCURLY -> } [200:8]
+    |       `--RCURLY -> } [201:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [202:4]
+    |   |--MODIFIERS -> MODIFIERS [202:4]
+    |   |--TYPE -> TYPE [202:4]
+    |   |   |--LITERAL_INT -> int [202:4]
+    |   |   |--ARRAY_DECLARATOR -> [ [202:7]
+    |   |   |   `--RBRACK -> ] [202:8]
+    |   |   |--ARRAY_DECLARATOR -> [ [202:9]
+    |   |   |   `--RBRACK -> ] [203:4]
+    |   |   |--ARRAY_DECLARATOR -> [ [205:5]
+    |   |   |   `--RBRACK -> ] [205:6]
+    |   |   `--ARRAY_DECLARATOR -> [ [206:12]
+    |   |       `--RBRACK -> ] [206:13]
+    |   |--IDENT -> w [204:5]
+    |   `--SEMI -> ; [206:15]
+    |--VARIABLE_DEF -> VARIABLE_DEF [207:4]
+    |   |--MODIFIERS -> MODIFIERS [207:4]
+    |   |--TYPE -> TYPE [207:4]
+    |   |   |--LITERAL_INT -> int [207:4]
+    |   |   |--ARRAY_DECLARATOR -> [ [207:7]
+    |   |   |   `--RBRACK -> ] [207:8]
+    |   |   |--ARRAY_DECLARATOR -> [ [207:9]
+    |   |   |   `--RBRACK -> ] [208:5]
+    |   |   |--ARRAY_DECLARATOR -> [ [210:4]
+    |   |   |   `--RBRACK -> ] [210:5]
+    |   |   `--ARRAY_DECLARATOR -> [ [211:12]
+    |   |       `--RBRACK -> ] [211:13]
+    |   |--IDENT -> z [209:5]
+    |   `--SEMI -> ; [211:15]
+    |--CLASS_DEF -> CLASS_DEF [213:4]
+    |   |--MODIFIERS -> MODIFIERS [213:4]
+    |   |   `--LITERAL_STATIC -> static [213:4]
+    |   |--LITERAL_CLASS -> class [213:11]
+    |   |--IDENT -> P [213:17]
+    |   `--OBJBLOCK -> OBJBLOCK [213:19]
+    |       |--LCURLY -> { [213:19]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [214:8]
+    |       |   |--MODIFIERS -> MODIFIERS [214:8]
+    |       |   |   `--LITERAL_PRIVATE -> private [214:8]
+    |       |   |--TYPE -> TYPE [214:16]
+    |       |   |   `--LITERAL_INT -> int [214:16]
+    |       |   |--IDENT -> x [214:20]
+    |       |   `--SEMI -> ; [214:21]
+    |       |--METHOD_DEF -> METHOD_DEF [216:8]
+    |       |   |--MODIFIERS -> MODIFIERS [216:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [216:8]
+    |       |   |--TYPE -> TYPE [216:15]
+    |       |   |   `--LITERAL_VOID -> void [216:15]
+    |       |   |--IDENT -> set3 [216:20]
+    |       |   |--LPAREN -> ( [216:24]
+    |       |   |--PARAMETERS -> PARAMETERS [216:25]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [216:25]
+    |       |   |       |--MODIFIERS -> MODIFIERS [216:25]
+    |       |   |       |--TYPE -> TYPE [216:25]
+    |       |   |       |   `--IDENT -> P [216:25]
+    |       |   |       `--IDENT -> p [216:27]
+    |       |   |--RPAREN -> ) [216:28]
+    |       |   `--SLIST -> { [216:30]
+    |       |       |--LITERAL_SYNCHRONIZED -> synchronized [217:14]
+    |       |       |   |--LPAREN -> ( [217:27]
+    |       |       |   |--EXPR -> EXPR [217:28]
+    |       |       |   |   `--LITERAL_THIS -> this [217:28]
+    |       |       |   |--RPAREN -> ) [217:32]
+    |       |       |   `--SLIST -> { [217:34]
+    |       |       |       |--EXPR -> EXPR [218:22]
+    |       |       |       |   `--ASSIGN -> = [218:22]
+    |       |       |       |       |--DOT -> . [218:19]
+    |       |       |       |       |   |--IDENT -> p [218:18]
+    |       |       |       |       |   `--IDENT -> x [218:20]
+    |       |       |       |       `--INDEX_OP -> [ [218:29]
+    |       |       |       |           |--METHOD_CALL -> ( [218:27]
+    |       |       |       |           |   |--IDENT -> get [218:24]
+    |       |       |       |           |   |--ELIST -> ELIST [218:28]
+    |       |       |       |           |   `--RPAREN -> ) [218:28]
+    |       |       |       |           |--EXPR -> EXPR [218:30]
+    |       |       |       |           |   `--NUM_INT -> 0 [218:30]
+    |       |       |       |           `--RBRACK -> ] [218:31]
+    |       |       |       |--SEMI -> ; [218:32]
+    |       |       |       `--RCURLY -> } [219:14]
+    |       |       `--RCURLY -> } [220:10]
+    |       |--METHOD_DEF -> METHOD_DEF [222:8]
+    |       |   |--MODIFIERS -> MODIFIERS [222:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [222:8]
+    |       |   |--TYPE -> TYPE [222:15]
+    |       |   |   `--LITERAL_VOID -> void [222:15]
+    |       |   |--IDENT -> set4 [222:20]
+    |       |   |--LPAREN -> ( [222:24]
+    |       |   |--PARAMETERS -> PARAMETERS [222:25]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [222:25]
+    |       |   |       |--MODIFIERS -> MODIFIERS [222:25]
+    |       |   |       |--TYPE -> TYPE [222:25]
+    |       |   |       |   `--IDENT -> P [222:25]
+    |       |   |       `--IDENT -> p [222:27]
+    |       |   |--RPAREN -> ) [222:28]
+    |       |   `--SLIST -> { [222:30]
+    |       |       |--LITERAL_SYNCHRONIZED -> synchronized [223:14]
+    |       |       |   |--LPAREN -> ( [223:26]
+    |       |       |   |--EXPR -> EXPR [223:27]
+    |       |       |   |   `--LITERAL_THIS -> this [223:27]
+    |       |       |   |--RPAREN -> ) [223:31]
+    |       |       |   `--SLIST -> { [223:33]
+    |       |       |       |--EXPR -> EXPR [224:22]
+    |       |       |       |   `--ASSIGN -> = [224:22]
+    |       |       |       |       |--DOT -> . [224:19]
+    |       |       |       |       |   |--IDENT -> p [224:18]
+    |       |       |       |       |   `--IDENT -> x [224:20]
+    |       |       |       |       `--INDEX_OP -> [ [224:29]
+    |       |       |       |           |--METHOD_CALL -> ( [224:27]
+    |       |       |       |           |   |--IDENT -> get [224:24]
+    |       |       |       |           |   |--ELIST -> ELIST [224:28]
+    |       |       |       |           |   `--RPAREN -> ) [224:28]
+    |       |       |       |           |--EXPR -> EXPR [224:30]
+    |       |       |       |           |   `--NUM_INT -> 0 [224:30]
+    |       |       |       |           `--RBRACK -> ] [224:31]
+    |       |       |       |--SEMI -> ; [224:32]
+    |       |       |       `--RCURLY -> } [225:14]
+    |       |       `--RCURLY -> } [226:10]
+    |       |--METHOD_DEF -> METHOD_DEF [228:8]
+    |       |   |--MODIFIERS -> MODIFIERS [228:8]
+    |       |   |   `--LITERAL_PRIVATE -> private [228:8]
+    |       |   |--TYPE -> TYPE [228:16]
+    |       |   |   |--LITERAL_INT -> int [228:16]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [228:19]
+    |       |   |       `--RBRACK -> ] [228:20]
+    |       |   |--IDENT -> get [228:22]
+    |       |   |--LPAREN -> ( [228:25]
+    |       |   |--PARAMETERS -> PARAMETERS [228:26]
+    |       |   |--RPAREN -> ) [228:26]
+    |       |   `--SLIST -> { [228:28]
+    |       |       |--LITERAL_RETURN -> return [229:12]
+    |       |       |   |--EXPR -> EXPR [229:19]
+    |       |       |   |   `--LITERAL_NULL -> null [229:19]
+    |       |       |   `--SEMI -> ; [229:23]
+    |       |       `--RCURLY -> } [230:8]
+    |       `--RCURLY -> } [231:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [233:4]
+    |   |--MODIFIERS -> MODIFIERS [233:4]
+    |   |   |--LITERAL_PRIVATE -> private [233:4]
+    |   |   `--ANNOTATION -> ANNOTATION [233:12]
+    |   |       |--AT -> @ [233:12]
+    |   |       `--IDENT -> Nullable [233:13]
+    |   |--TYPE -> TYPE [233:22]
+    |   |   |--LITERAL_INT -> int [233:22]
+    |   |   |--ANNOTATIONS -> ANNOTATIONS [233:33]
+    |   |   |   `--ANNOTATION -> ANNOTATION [233:33]
+    |   |   |       |--AT -> @ [233:33]
+    |   |   |       `--IDENT -> Nullable [233:34]
+    |   |   |--ARRAY_DECLARATOR -> [ [233:43]
+    |   |   |   `--RBRACK -> ] [233:44]
+    |   |   |--ANNOTATIONS -> ANNOTATIONS [233:46]
+    |   |   |   `--ANNOTATION -> ANNOTATION [233:46]
+    |   |   |       |--AT -> @ [233:46]
+    |   |   |       `--IDENT -> Nullable [233:47]
+    |   |   `--ARRAY_DECLARATOR -> [ [233:56]
+    |   |       `--RBRACK -> ] [233:57]
+    |   |--IDENT -> array2 [233:26]
+    |   `--SEMI -> ; [233:58]
+    `--RCURLY -> } [234:0]
+ANNOTATION_DEF -> ANNOTATION_DEF [237:0]
+|--MODIFIERS -> MODIFIERS [237:0]
+|   `--ANNOTATION -> ANNOTATION [237:0]
+|       |--AT -> @ [237:0]
+|       |--IDENT -> Target [237:1]
+|       |--LPAREN -> ( [237:7]
+|       |--ANNOTATION_ARRAY_INIT -> { [237:8]
+|       |   |--EXPR -> EXPR [237:20]
+|       |   |   `--DOT -> . [237:20]
+|       |   |       |--IDENT -> ElementType [237:9]
+|       |   |       `--IDENT -> TYPE_USE [237:21]
+|       |   |--COMMA -> , [237:29]
+|       |   |--EXPR -> EXPR [237:42]
+|       |   |   `--DOT -> . [237:42]
+|       |   |       |--IDENT -> ElementType [237:31]
+|       |   |       `--IDENT -> TYPE_PARAMETER [237:43]
+|       |   `--RCURLY -> } [237:57]
+|       `--RPAREN -> ) [237:58]
+|--AT -> @ [238:0]
+|--LITERAL_INTERFACE -> interface [238:1]
+|--IDENT -> Nullable [238:11]
+`--OBJBLOCK -> OBJBLOCK [238:19]
+    |--LCURLY -> { [238:19]
+    `--RCURLY -> } [238:20]
+ANNOTATION_DEF -> ANNOTATION_DEF [240:0]
+|--MODIFIERS -> MODIFIERS [240:0]
+|   `--ANNOTATION -> ANNOTATION [240:0]
+|       |--AT -> @ [240:0]
+|       |--IDENT -> Target [240:1]
+|       |--LPAREN -> ( [240:7]
+|       |--ANNOTATION_ARRAY_INIT -> { [240:8]
+|       |   |--EXPR -> EXPR [240:20]
+|       |   |   `--DOT -> . [240:20]
+|       |   |       |--IDENT -> ElementType [240:9]
+|       |   |       `--IDENT -> TYPE_USE [240:21]
+|       |   |--COMMA -> , [240:29]
+|       |   |--EXPR -> EXPR [240:42]
+|       |   |   `--DOT -> . [240:42]
+|       |   |       |--IDENT -> ElementType [240:31]
+|       |   |       `--IDENT -> TYPE_PARAMETER [240:43]
+|       |   `--RCURLY -> } [240:57]
+|       `--RPAREN -> ) [240:58]
+|--AT -> @ [241:0]
+|--LITERAL_INTERFACE -> interface [241:1]
+|--IDENT -> I [241:11]
+`--OBJBLOCK -> OBJBLOCK [241:13]
+    |--LCURLY -> { [241:13]
+    `--RCURLY -> } [241:14]
+ANNOTATION_DEF -> ANNOTATION_DEF [243:0]
+|--MODIFIERS -> MODIFIERS [243:0]
+|   `--ANNOTATION -> ANNOTATION [243:0]
+|       |--AT -> @ [243:0]
+|       |--IDENT -> Target [243:1]
+|       |--LPAREN -> ( [243:7]
+|       |--ANNOTATION_ARRAY_INIT -> { [243:8]
+|       |   |--EXPR -> EXPR [243:20]
+|       |   |   `--DOT -> . [243:20]
+|       |   |       |--IDENT -> ElementType [243:9]
+|       |   |       `--IDENT -> TYPE_USE [243:21]
+|       |   |--COMMA -> , [243:29]
+|       |   |--EXPR -> EXPR [243:42]
+|       |   |   `--DOT -> . [243:42]
+|       |   |       |--IDENT -> ElementType [243:31]
+|       |   |       `--IDENT -> TYPE_PARAMETER [243:43]
+|       |   `--RCURLY -> } [243:57]
+|       `--RPAREN -> ) [243:58]
+|--AT -> @ [244:0]
+|--LITERAL_INTERFACE -> interface [244:1]
+|--IDENT -> J [244:11]
+`--OBJBLOCK -> OBJBLOCK [244:13]
+    |--LCURLY -> { [244:13]
+    `--RCURLY -> } [244:14]
+ANNOTATION_DEF -> ANNOTATION_DEF [246:0]
+|--MODIFIERS -> MODIFIERS [246:0]
+|   `--ANNOTATION -> ANNOTATION [246:0]
+|       |--AT -> @ [246:0]
+|       |--IDENT -> Target [246:1]
+|       |--LPAREN -> ( [246:7]
+|       |--ANNOTATION_ARRAY_INIT -> { [246:8]
+|       |   |--EXPR -> EXPR [246:20]
+|       |   |   `--DOT -> . [246:20]
+|       |   |       |--IDENT -> ElementType [246:9]
+|       |   |       `--IDENT -> TYPE_USE [246:21]
+|       |   |--COMMA -> , [246:29]
+|       |   |--EXPR -> EXPR [246:42]
+|       |   |   `--DOT -> . [246:42]
+|       |   |       |--IDENT -> ElementType [246:31]
+|       |   |       `--IDENT -> TYPE_PARAMETER [246:43]
+|       |   `--RCURLY -> } [246:57]
+|       `--RPAREN -> ) [246:58]
+|--AT -> @ [247:0]
+|--LITERAL_INTERFACE -> interface [247:1]
+|--IDENT -> K [247:11]
+`--OBJBLOCK -> OBJBLOCK [247:13]
+    |--LCURLY -> { [247:13]
+    `--RCURLY -> } [247:14]
+ANNOTATION_DEF -> ANNOTATION_DEF [249:0]
+|--MODIFIERS -> MODIFIERS [249:0]
+|   `--ANNOTATION -> ANNOTATION [249:0]
+|       |--AT -> @ [249:0]
+|       |--IDENT -> Target [249:1]
+|       |--LPAREN -> ( [249:7]
+|       |--ANNOTATION_ARRAY_INIT -> { [249:8]
+|       |   |--EXPR -> EXPR [249:20]
+|       |   |   `--DOT -> . [249:20]
+|       |   |       |--IDENT -> ElementType [249:9]
+|       |   |       `--IDENT -> TYPE_USE [249:21]
+|       |   |--COMMA -> , [249:29]
+|       |   |--EXPR -> EXPR [249:42]
+|       |   |   `--DOT -> . [249:42]
+|       |   |       |--IDENT -> ElementType [249:31]
+|       |   |       `--IDENT -> TYPE_PARAMETER [249:43]
+|       |   `--RCURLY -> } [249:57]
+|       `--RPAREN -> ) [249:58]
+|--AT -> @ [250:0]
+|--LITERAL_INTERFACE -> interface [250:1]
+|--IDENT -> L [250:11]
+`--OBJBLOCK -> OBJBLOCK [250:13]
+    |--LCURLY -> { [250:13]
+    `--RCURLY -> } [250:14]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionPackage.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionPackage.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionPackage.java
@@ -0,0 +1 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionPackage.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionPackage.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionPackage.txt
@@ -0,0 +1,14 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionPackageAnnotation.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionPackageAnnotation.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionPackageAnnotation.txt
@@ -0,0 +1,38 @@
+PACKAGE_DEF -> package [6:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:0]
+|   |--ANNOTATION -> ANNOTATION [1:0]
+|   |   |--AT -> @ [1:0]
+|   |   |--IDENT -> PackageAnnotation [1:1]
+|   |   |--LPAREN -> ( [1:18]
+|   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [1:19]
+|   |   |   |--IDENT -> value [1:19]
+|   |   |   |--ASSIGN -> = [1:25]
+|   |   |   `--EXPR -> EXPR [1:27]
+|   |   |       `--STRING_LITERAL -> "foo" [1:27]
+|   |   `--RPAREN -> ) [1:32]
+|   |--ANNOTATION -> ANNOTATION [2:2]
+|   |   |--AT -> @ [2:2]
+|   |   |--IDENT -> PackageAnnotation [2:3]
+|   |   |--LPAREN -> ( [2:20]
+|   |   |--EXPR -> EXPR [2:21]
+|   |   |   `--STRING_LITERAL -> "" [2:21]
+|   |   `--RPAREN -> ) [2:23]
+|   `--ANNOTATION -> ANNOTATION [3:0]
+|       |--AT -> @ [3:0]
+|       |--IDENT -> PackageAnnotation [3:1]
+|       |--LPAREN -> ( [3:18]
+|       |--EXPR -> EXPR [4:8]
+|       |   `--STRING_LITERAL -> "bar" [4:8]
+|       `--RPAREN -> ) [5:0]
+|--DOT -> . [11:16]
+|   |--DOT -> . [10:27]
+|   |   |--DOT -> . [10:16]
+|   |   |   |--DOT -> . [8:26]
+|   |   |   |   |--DOT -> . [7:11]
+|   |   |   |   |   |--IDENT -> com [7:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [8:16]
+|   |   |   |   `--IDENT -> tools [9:16]
+|   |   |   `--IDENT -> checkstyle [10:17]
+|   |   `--IDENT -> grammar [10:28]
+|   `--IDENT -> antlr4 [11:17]
+`--SEMI -> ; [11:23]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSimple.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSimple.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSimple.java
@@ -0,0 +1,17 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+public class InputAntlr4AstRegressionSimple {
+
+    int w, a;
+
+    public static void main(String... args) {
+        int[][] z = {{1}};
+        String s = "Hello world!";
+    }
+
+    private void method(String x, Integer y, String... arr) {
+        for (int i = 0; i < arr.length; i++) {
+            System.out.println(arr[i]);
+        }
+    }
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSimple.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSimple.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSimple.txt
@@ -0,0 +1,151 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+CLASS_DEF -> CLASS_DEF [3:0]
+|--MODIFIERS -> MODIFIERS [3:0]
+|   `--LITERAL_PUBLIC -> public [3:0]
+|--LITERAL_CLASS -> class [3:7]
+|--IDENT -> InputAntlr4AstRegressionSimple [3:13]
+`--OBJBLOCK -> OBJBLOCK [3:44]
+    |--LCURLY -> { [3:44]
+    |--VARIABLE_DEF -> VARIABLE_DEF [5:4]
+    |   |--MODIFIERS -> MODIFIERS [5:4]
+    |   |--TYPE -> TYPE [5:4]
+    |   |   `--LITERAL_INT -> int [5:4]
+    |   |--IDENT -> w [5:8]
+    |   `--SEMI -> ; [5:12]
+    |--COMMA -> , [5:9]
+    |--VARIABLE_DEF -> VARIABLE_DEF [5:4]
+    |   |--MODIFIERS -> MODIFIERS [5:4]
+    |   |--TYPE -> TYPE [5:4]
+    |   |   `--LITERAL_INT -> int [5:4]
+    |   `--IDENT -> a [5:11]
+    |--METHOD_DEF -> METHOD_DEF [7:4]
+    |   |--MODIFIERS -> MODIFIERS [7:4]
+    |   |   |--LITERAL_PUBLIC -> public [7:4]
+    |   |   `--LITERAL_STATIC -> static [7:11]
+    |   |--TYPE -> TYPE [7:18]
+    |   |   `--LITERAL_VOID -> void [7:18]
+    |   |--IDENT -> main [7:23]
+    |   |--LPAREN -> ( [7:27]
+    |   |--PARAMETERS -> PARAMETERS [7:28]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [7:28]
+    |   |       |--MODIFIERS -> MODIFIERS [7:28]
+    |   |       |--TYPE -> TYPE [7:28]
+    |   |       |   `--IDENT -> String [7:28]
+    |   |       |--ELLIPSIS -> ... [7:34]
+    |   |       `--IDENT -> args [7:38]
+    |   |--RPAREN -> ) [7:42]
+    |   `--SLIST -> { [7:44]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [8:8]
+    |       |   |--MODIFIERS -> MODIFIERS [8:8]
+    |       |   |--TYPE -> TYPE [8:8]
+    |       |   |   |--LITERAL_INT -> int [8:8]
+    |       |   |   |--ARRAY_DECLARATOR -> [ [8:11]
+    |       |   |   |   `--RBRACK -> ] [8:12]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [8:13]
+    |       |   |       `--RBRACK -> ] [8:14]
+    |       |   |--IDENT -> z [8:16]
+    |       |   `--ASSIGN -> = [8:18]
+    |       |       `--ARRAY_INIT -> { [8:20]
+    |       |           |--ARRAY_INIT -> { [8:21]
+    |       |           |   |--EXPR -> EXPR [8:22]
+    |       |           |   |   `--NUM_INT -> 1 [8:22]
+    |       |           |   `--RCURLY -> } [8:23]
+    |       |           `--RCURLY -> } [8:24]
+    |       |--SEMI -> ; [8:25]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [9:8]
+    |       |   |--MODIFIERS -> MODIFIERS [9:8]
+    |       |   |--TYPE -> TYPE [9:8]
+    |       |   |   `--IDENT -> String [9:8]
+    |       |   |--IDENT -> s [9:15]
+    |       |   `--ASSIGN -> = [9:17]
+    |       |       `--EXPR -> EXPR [9:19]
+    |       |           `--STRING_LITERAL -> "Hello world!" [9:19]
+    |       |--SEMI -> ; [9:33]
+    |       `--RCURLY -> } [10:4]
+    |--METHOD_DEF -> METHOD_DEF [12:4]
+    |   |--MODIFIERS -> MODIFIERS [12:4]
+    |   |   `--LITERAL_PRIVATE -> private [12:4]
+    |   |--TYPE -> TYPE [12:12]
+    |   |   `--LITERAL_VOID -> void [12:12]
+    |   |--IDENT -> method [12:17]
+    |   |--LPAREN -> ( [12:23]
+    |   |--PARAMETERS -> PARAMETERS [12:24]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [12:24]
+    |   |   |   |--MODIFIERS -> MODIFIERS [12:24]
+    |   |   |   |--TYPE -> TYPE [12:24]
+    |   |   |   |   `--IDENT -> String [12:24]
+    |   |   |   `--IDENT -> x [12:31]
+    |   |   |--COMMA -> , [12:32]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [12:34]
+    |   |   |   |--MODIFIERS -> MODIFIERS [12:34]
+    |   |   |   |--TYPE -> TYPE [12:34]
+    |   |   |   |   `--IDENT -> Integer [12:34]
+    |   |   |   `--IDENT -> y [12:42]
+    |   |   |--COMMA -> , [12:43]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [12:45]
+    |   |       |--MODIFIERS -> MODIFIERS [12:45]
+    |   |       |--TYPE -> TYPE [12:45]
+    |   |       |   `--IDENT -> String [12:45]
+    |   |       |--ELLIPSIS -> ... [12:51]
+    |   |       `--IDENT -> arr [12:55]
+    |   |--RPAREN -> ) [12:58]
+    |   `--SLIST -> { [12:60]
+    |       |--LITERAL_FOR -> for [13:8]
+    |       |   |--LPAREN -> ( [13:12]
+    |       |   |--FOR_INIT -> FOR_INIT [13:13]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [13:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [13:13]
+    |       |   |       |--TYPE -> TYPE [13:13]
+    |       |   |       |   `--LITERAL_INT -> int [13:13]
+    |       |   |       |--IDENT -> i [13:17]
+    |       |   |       `--ASSIGN -> = [13:19]
+    |       |   |           `--EXPR -> EXPR [13:21]
+    |       |   |               `--NUM_INT -> 0 [13:21]
+    |       |   |--SEMI -> ; [13:22]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [13:26]
+    |       |   |   `--EXPR -> EXPR [13:26]
+    |       |   |       `--LT -> < [13:26]
+    |       |   |           |--IDENT -> i [13:24]
+    |       |   |           `--DOT -> . [13:31]
+    |       |   |               |--IDENT -> arr [13:28]
+    |       |   |               `--IDENT -> length [13:32]
+    |       |   |--SEMI -> ; [13:38]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [13:41]
+    |       |   |   `--ELIST -> ELIST [13:41]
+    |       |   |       `--EXPR -> EXPR [13:41]
+    |       |   |           `--POST_INC -> ++ [13:41]
+    |       |   |               `--IDENT -> i [13:40]
+    |       |   |--RPAREN -> ) [13:43]
+    |       |   `--SLIST -> { [13:45]
+    |       |       |--EXPR -> EXPR [14:30]
+    |       |       |   `--METHOD_CALL -> ( [14:30]
+    |       |       |       |--DOT -> . [14:22]
+    |       |       |       |   |--DOT -> . [14:18]
+    |       |       |       |   |   |--IDENT -> System [14:12]
+    |       |       |       |   |   `--IDENT -> out [14:19]
+    |       |       |       |   `--IDENT -> println [14:23]
+    |       |       |       |--ELIST -> ELIST [14:34]
+    |       |       |       |   `--EXPR -> EXPR [14:34]
+    |       |       |       |       `--INDEX_OP -> [ [14:34]
+    |       |       |       |           |--IDENT -> arr [14:31]
+    |       |       |       |           |--EXPR -> EXPR [14:35]
+    |       |       |       |           |   `--IDENT -> i [14:35]
+    |       |       |       |           `--RBRACK -> ] [14:36]
+    |       |       |       `--RPAREN -> ) [14:37]
+    |       |       |--SEMI -> ; [14:38]
+    |       |       `--RCURLY -> } [15:8]
+    |       `--RCURLY -> } [16:4]
+    `--RCURLY -> } [17:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSimpleWithAnno.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSimpleWithAnno.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSimpleWithAnno.java
@@ -0,0 +1,5 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+@Deprecated
+public class InputAntlr4AstRegressionSimpleWithAnno {
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSimpleWithAnno.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSimpleWithAnno.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSimpleWithAnno.txt
@@ -0,0 +1,25 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+CLASS_DEF -> CLASS_DEF [3:0]
+|--MODIFIERS -> MODIFIERS [3:0]
+|   |--ANNOTATION -> ANNOTATION [3:0]
+|   |   |--AT -> @ [3:0]
+|   |   `--IDENT -> Deprecated [3:1]
+|   `--LITERAL_PUBLIC -> public [4:0]
+|--LITERAL_CLASS -> class [4:7]
+|--IDENT -> InputAntlr4AstRegressionSimpleWithAnno [4:13]
+`--OBJBLOCK -> OBJBLOCK [4:52]
+    |--LCURLY -> { [4:52]
+    `--RCURLY -> } [5:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSingleLineBlocks.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSingleLineBlocks.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSingleLineBlocks.java
@@ -0,0 +1,71 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+public class InputAntlr4AstRegressionSingleLineBlocks {
+
+    public void testMethod() {}; // ok
+
+    public void testMethod1() {
+    }; // violation
+
+    public class TestClass {}; // ok
+
+    public class TestClass1 {
+    }; // violation
+
+    public class TestClass2 {
+        public TestClass2() {}; // ok
+
+        public TestClass2(String someValue) {
+        }; // violation
+    }
+
+    public void testMethod11() {
+    }
+    ;
+
+    public @interface TestAnnnotation5 {
+        String someValue(); }; // violation
+
+    public @interface TestAnnotation6 {}; // ok
+
+    public @interface TestAnnotation7 {
+        String someValue();
+    }; // violation
+
+    public @interface TestAnnotation8 { String someValue();
+    }; // violation
+
+    public @interface TestAnnotation9 { String someValue(); }; // ok
+
+    enum TestEnum{}; // ok
+
+    enum TestEnum1{
+        SOME_VALUE;}; // violation
+
+    enum TestEnum2 { SOME_VALUE; }; // ok
+
+    enum TestEnum3{
+        SOME_VALUE;
+    }; // violation
+
+    enum TestEnum4{ SOME_VALUE;
+    }; // violation
+
+    interface Interface1
+    {
+        int i = 1;
+        public void meth1(); }; // violation
+
+    interface Interface2
+    { int i = 1; public void meth1(); };
+
+    interface Interface3 {
+        void display();
+        interface Interface4 {
+            void myMethod();
+        };}; // 2 violations
+
+    interface InterfaceEndingWithSemiColon2 {
+        public void fooEmpty();
+    }; // violation
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSingleLineBlocks.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSingleLineBlocks.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSingleLineBlocks.txt
@@ -0,0 +1,353 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+CLASS_DEF -> CLASS_DEF [3:0]
+|--MODIFIERS -> MODIFIERS [3:0]
+|   `--LITERAL_PUBLIC -> public [3:0]
+|--LITERAL_CLASS -> class [3:7]
+|--IDENT -> InputAntlr4AstRegressionSingleLineBlocks [3:13]
+`--OBJBLOCK -> OBJBLOCK [3:54]
+    |--LCURLY -> { [3:54]
+    |--METHOD_DEF -> METHOD_DEF [5:4]
+    |   |--MODIFIERS -> MODIFIERS [5:4]
+    |   |   `--LITERAL_PUBLIC -> public [5:4]
+    |   |--TYPE -> TYPE [5:11]
+    |   |   `--LITERAL_VOID -> void [5:11]
+    |   |--IDENT -> testMethod [5:16]
+    |   |--LPAREN -> ( [5:26]
+    |   |--PARAMETERS -> PARAMETERS [5:27]
+    |   |--RPAREN -> ) [5:27]
+    |   `--SLIST -> { [5:29]
+    |       `--RCURLY -> } [5:30]
+    |--SEMI -> ; [5:31]
+    |--METHOD_DEF -> METHOD_DEF [7:4]
+    |   |--MODIFIERS -> MODIFIERS [7:4]
+    |   |   `--LITERAL_PUBLIC -> public [7:4]
+    |   |--TYPE -> TYPE [7:11]
+    |   |   `--LITERAL_VOID -> void [7:11]
+    |   |--IDENT -> testMethod1 [7:16]
+    |   |--LPAREN -> ( [7:27]
+    |   |--PARAMETERS -> PARAMETERS [7:28]
+    |   |--RPAREN -> ) [7:28]
+    |   `--SLIST -> { [7:30]
+    |       `--RCURLY -> } [8:4]
+    |--SEMI -> ; [8:5]
+    |--CLASS_DEF -> CLASS_DEF [10:4]
+    |   |--MODIFIERS -> MODIFIERS [10:4]
+    |   |   `--LITERAL_PUBLIC -> public [10:4]
+    |   |--LITERAL_CLASS -> class [10:11]
+    |   |--IDENT -> TestClass [10:17]
+    |   `--OBJBLOCK -> OBJBLOCK [10:27]
+    |       |--LCURLY -> { [10:27]
+    |       `--RCURLY -> } [10:28]
+    |--SEMI -> ; [10:29]
+    |--CLASS_DEF -> CLASS_DEF [12:4]
+    |   |--MODIFIERS -> MODIFIERS [12:4]
+    |   |   `--LITERAL_PUBLIC -> public [12:4]
+    |   |--LITERAL_CLASS -> class [12:11]
+    |   |--IDENT -> TestClass1 [12:17]
+    |   `--OBJBLOCK -> OBJBLOCK [12:28]
+    |       |--LCURLY -> { [12:28]
+    |       `--RCURLY -> } [13:4]
+    |--SEMI -> ; [13:5]
+    |--CLASS_DEF -> CLASS_DEF [15:4]
+    |   |--MODIFIERS -> MODIFIERS [15:4]
+    |   |   `--LITERAL_PUBLIC -> public [15:4]
+    |   |--LITERAL_CLASS -> class [15:11]
+    |   |--IDENT -> TestClass2 [15:17]
+    |   `--OBJBLOCK -> OBJBLOCK [15:28]
+    |       |--LCURLY -> { [15:28]
+    |       |--CTOR_DEF -> CTOR_DEF [16:8]
+    |       |   |--MODIFIERS -> MODIFIERS [16:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [16:8]
+    |       |   |--IDENT -> TestClass2 [16:15]
+    |       |   |--LPAREN -> ( [16:25]
+    |       |   |--PARAMETERS -> PARAMETERS [16:26]
+    |       |   |--RPAREN -> ) [16:26]
+    |       |   `--SLIST -> { [16:28]
+    |       |       `--RCURLY -> } [16:29]
+    |       |--SEMI -> ; [16:30]
+    |       |--CTOR_DEF -> CTOR_DEF [18:8]
+    |       |   |--MODIFIERS -> MODIFIERS [18:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [18:8]
+    |       |   |--IDENT -> TestClass2 [18:15]
+    |       |   |--LPAREN -> ( [18:25]
+    |       |   |--PARAMETERS -> PARAMETERS [18:26]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [18:26]
+    |       |   |       |--MODIFIERS -> MODIFIERS [18:26]
+    |       |   |       |--TYPE -> TYPE [18:26]
+    |       |   |       |   `--IDENT -> String [18:26]
+    |       |   |       `--IDENT -> someValue [18:33]
+    |       |   |--RPAREN -> ) [18:42]
+    |       |   `--SLIST -> { [18:44]
+    |       |       `--RCURLY -> } [19:8]
+    |       |--SEMI -> ; [19:9]
+    |       `--RCURLY -> } [20:4]
+    |--METHOD_DEF -> METHOD_DEF [22:4]
+    |   |--MODIFIERS -> MODIFIERS [22:4]
+    |   |   `--LITERAL_PUBLIC -> public [22:4]
+    |   |--TYPE -> TYPE [22:11]
+    |   |   `--LITERAL_VOID -> void [22:11]
+    |   |--IDENT -> testMethod11 [22:16]
+    |   |--LPAREN -> ( [22:28]
+    |   |--PARAMETERS -> PARAMETERS [22:29]
+    |   |--RPAREN -> ) [22:29]
+    |   `--SLIST -> { [22:31]
+    |       `--RCURLY -> } [23:4]
+    |--SEMI -> ; [24:4]
+    |--ANNOTATION_DEF -> ANNOTATION_DEF [26:4]
+    |   |--MODIFIERS -> MODIFIERS [26:4]
+    |   |   `--LITERAL_PUBLIC -> public [26:4]
+    |   |--AT -> @ [26:11]
+    |   |--LITERAL_INTERFACE -> interface [26:12]
+    |   |--IDENT -> TestAnnnotation5 [26:22]
+    |   `--OBJBLOCK -> OBJBLOCK [26:39]
+    |       |--LCURLY -> { [26:39]
+    |       |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [27:8]
+    |       |   |--MODIFIERS -> MODIFIERS [27:8]
+    |       |   |--TYPE -> TYPE [27:8]
+    |       |   |   `--IDENT -> String [27:8]
+    |       |   |--IDENT -> someValue [27:15]
+    |       |   |--LPAREN -> ( [27:24]
+    |       |   |--RPAREN -> ) [27:25]
+    |       |   `--SEMI -> ; [27:26]
+    |       `--RCURLY -> } [27:28]
+    |--SEMI -> ; [27:29]
+    |--ANNOTATION_DEF -> ANNOTATION_DEF [29:4]
+    |   |--MODIFIERS -> MODIFIERS [29:4]
+    |   |   `--LITERAL_PUBLIC -> public [29:4]
+    |   |--AT -> @ [29:11]
+    |   |--LITERAL_INTERFACE -> interface [29:12]
+    |   |--IDENT -> TestAnnotation6 [29:22]
+    |   `--OBJBLOCK -> OBJBLOCK [29:38]
+    |       |--LCURLY -> { [29:38]
+    |       `--RCURLY -> } [29:39]
+    |--SEMI -> ; [29:40]
+    |--ANNOTATION_DEF -> ANNOTATION_DEF [31:4]
+    |   |--MODIFIERS -> MODIFIERS [31:4]
+    |   |   `--LITERAL_PUBLIC -> public [31:4]
+    |   |--AT -> @ [31:11]
+    |   |--LITERAL_INTERFACE -> interface [31:12]
+    |   |--IDENT -> TestAnnotation7 [31:22]
+    |   `--OBJBLOCK -> OBJBLOCK [31:38]
+    |       |--LCURLY -> { [31:38]
+    |       |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [32:8]
+    |       |   |--MODIFIERS -> MODIFIERS [32:8]
+    |       |   |--TYPE -> TYPE [32:8]
+    |       |   |   `--IDENT -> String [32:8]
+    |       |   |--IDENT -> someValue [32:15]
+    |       |   |--LPAREN -> ( [32:24]
+    |       |   |--RPAREN -> ) [32:25]
+    |       |   `--SEMI -> ; [32:26]
+    |       `--RCURLY -> } [33:4]
+    |--SEMI -> ; [33:5]
+    |--ANNOTATION_DEF -> ANNOTATION_DEF [35:4]
+    |   |--MODIFIERS -> MODIFIERS [35:4]
+    |   |   `--LITERAL_PUBLIC -> public [35:4]
+    |   |--AT -> @ [35:11]
+    |   |--LITERAL_INTERFACE -> interface [35:12]
+    |   |--IDENT -> TestAnnotation8 [35:22]
+    |   `--OBJBLOCK -> OBJBLOCK [35:38]
+    |       |--LCURLY -> { [35:38]
+    |       |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [35:40]
+    |       |   |--MODIFIERS -> MODIFIERS [35:40]
+    |       |   |--TYPE -> TYPE [35:40]
+    |       |   |   `--IDENT -> String [35:40]
+    |       |   |--IDENT -> someValue [35:47]
+    |       |   |--LPAREN -> ( [35:56]
+    |       |   |--RPAREN -> ) [35:57]
+    |       |   `--SEMI -> ; [35:58]
+    |       `--RCURLY -> } [36:4]
+    |--SEMI -> ; [36:5]
+    |--ANNOTATION_DEF -> ANNOTATION_DEF [38:4]
+    |   |--MODIFIERS -> MODIFIERS [38:4]
+    |   |   `--LITERAL_PUBLIC -> public [38:4]
+    |   |--AT -> @ [38:11]
+    |   |--LITERAL_INTERFACE -> interface [38:12]
+    |   |--IDENT -> TestAnnotation9 [38:22]
+    |   `--OBJBLOCK -> OBJBLOCK [38:38]
+    |       |--LCURLY -> { [38:38]
+    |       |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [38:40]
+    |       |   |--MODIFIERS -> MODIFIERS [38:40]
+    |       |   |--TYPE -> TYPE [38:40]
+    |       |   |   `--IDENT -> String [38:40]
+    |       |   |--IDENT -> someValue [38:47]
+    |       |   |--LPAREN -> ( [38:56]
+    |       |   |--RPAREN -> ) [38:57]
+    |       |   `--SEMI -> ; [38:58]
+    |       `--RCURLY -> } [38:60]
+    |--SEMI -> ; [38:61]
+    |--ENUM_DEF -> ENUM_DEF [40:4]
+    |   |--MODIFIERS -> MODIFIERS [40:4]
+    |   |--ENUM -> enum [40:4]
+    |   |--IDENT -> TestEnum [40:9]
+    |   `--OBJBLOCK -> OBJBLOCK [40:17]
+    |       |--LCURLY -> { [40:17]
+    |       `--RCURLY -> } [40:18]
+    |--SEMI -> ; [40:19]
+    |--ENUM_DEF -> ENUM_DEF [42:4]
+    |   |--MODIFIERS -> MODIFIERS [42:4]
+    |   |--ENUM -> enum [42:4]
+    |   |--IDENT -> TestEnum1 [42:9]
+    |   `--OBJBLOCK -> OBJBLOCK [42:18]
+    |       |--LCURLY -> { [42:18]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [43:8]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [43:8]
+    |       |   `--IDENT -> SOME_VALUE [43:8]
+    |       |--SEMI -> ; [43:18]
+    |       `--RCURLY -> } [43:19]
+    |--SEMI -> ; [43:20]
+    |--ENUM_DEF -> ENUM_DEF [45:4]
+    |   |--MODIFIERS -> MODIFIERS [45:4]
+    |   |--ENUM -> enum [45:4]
+    |   |--IDENT -> TestEnum2 [45:9]
+    |   `--OBJBLOCK -> OBJBLOCK [45:19]
+    |       |--LCURLY -> { [45:19]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [45:21]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [45:21]
+    |       |   `--IDENT -> SOME_VALUE [45:21]
+    |       |--SEMI -> ; [45:31]
+    |       `--RCURLY -> } [45:33]
+    |--SEMI -> ; [45:34]
+    |--ENUM_DEF -> ENUM_DEF [47:4]
+    |   |--MODIFIERS -> MODIFIERS [47:4]
+    |   |--ENUM -> enum [47:4]
+    |   |--IDENT -> TestEnum3 [47:9]
+    |   `--OBJBLOCK -> OBJBLOCK [47:18]
+    |       |--LCURLY -> { [47:18]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [48:8]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [48:8]
+    |       |   `--IDENT -> SOME_VALUE [48:8]
+    |       |--SEMI -> ; [48:18]
+    |       `--RCURLY -> } [49:4]
+    |--SEMI -> ; [49:5]
+    |--ENUM_DEF -> ENUM_DEF [51:4]
+    |   |--MODIFIERS -> MODIFIERS [51:4]
+    |   |--ENUM -> enum [51:4]
+    |   |--IDENT -> TestEnum4 [51:9]
+    |   `--OBJBLOCK -> OBJBLOCK [51:18]
+    |       |--LCURLY -> { [51:18]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [51:20]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [51:20]
+    |       |   `--IDENT -> SOME_VALUE [51:20]
+    |       |--SEMI -> ; [51:30]
+    |       `--RCURLY -> } [52:4]
+    |--SEMI -> ; [52:5]
+    |--INTERFACE_DEF -> INTERFACE_DEF [54:4]
+    |   |--MODIFIERS -> MODIFIERS [54:4]
+    |   |--LITERAL_INTERFACE -> interface [54:4]
+    |   |--IDENT -> Interface1 [54:14]
+    |   `--OBJBLOCK -> OBJBLOCK [55:4]
+    |       |--LCURLY -> { [55:4]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [56:8]
+    |       |   |--MODIFIERS -> MODIFIERS [56:8]
+    |       |   |--TYPE -> TYPE [56:8]
+    |       |   |   `--LITERAL_INT -> int [56:8]
+    |       |   |--IDENT -> i [56:12]
+    |       |   |--ASSIGN -> = [56:14]
+    |       |   |   `--EXPR -> EXPR [56:16]
+    |       |   |       `--NUM_INT -> 1 [56:16]
+    |       |   `--SEMI -> ; [56:17]
+    |       |--METHOD_DEF -> METHOD_DEF [57:8]
+    |       |   |--MODIFIERS -> MODIFIERS [57:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [57:8]
+    |       |   |--TYPE -> TYPE [57:15]
+    |       |   |   `--LITERAL_VOID -> void [57:15]
+    |       |   |--IDENT -> meth1 [57:20]
+    |       |   |--LPAREN -> ( [57:25]
+    |       |   |--PARAMETERS -> PARAMETERS [57:26]
+    |       |   |--RPAREN -> ) [57:26]
+    |       |   `--SEMI -> ; [57:27]
+    |       `--RCURLY -> } [57:29]
+    |--SEMI -> ; [57:30]
+    |--INTERFACE_DEF -> INTERFACE_DEF [59:4]
+    |   |--MODIFIERS -> MODIFIERS [59:4]
+    |   |--LITERAL_INTERFACE -> interface [59:4]
+    |   |--IDENT -> Interface2 [59:14]
+    |   `--OBJBLOCK -> OBJBLOCK [60:4]
+    |       |--LCURLY -> { [60:4]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [60:6]
+    |       |   |--MODIFIERS -> MODIFIERS [60:6]
+    |       |   |--TYPE -> TYPE [60:6]
+    |       |   |   `--LITERAL_INT -> int [60:6]
+    |       |   |--IDENT -> i [60:10]
+    |       |   |--ASSIGN -> = [60:12]
+    |       |   |   `--EXPR -> EXPR [60:14]
+    |       |   |       `--NUM_INT -> 1 [60:14]
+    |       |   `--SEMI -> ; [60:15]
+    |       |--METHOD_DEF -> METHOD_DEF [60:17]
+    |       |   |--MODIFIERS -> MODIFIERS [60:17]
+    |       |   |   `--LITERAL_PUBLIC -> public [60:17]
+    |       |   |--TYPE -> TYPE [60:24]
+    |       |   |   `--LITERAL_VOID -> void [60:24]
+    |       |   |--IDENT -> meth1 [60:29]
+    |       |   |--LPAREN -> ( [60:34]
+    |       |   |--PARAMETERS -> PARAMETERS [60:35]
+    |       |   |--RPAREN -> ) [60:35]
+    |       |   `--SEMI -> ; [60:36]
+    |       `--RCURLY -> } [60:38]
+    |--SEMI -> ; [60:39]
+    |--INTERFACE_DEF -> INTERFACE_DEF [62:4]
+    |   |--MODIFIERS -> MODIFIERS [62:4]
+    |   |--LITERAL_INTERFACE -> interface [62:4]
+    |   |--IDENT -> Interface3 [62:14]
+    |   `--OBJBLOCK -> OBJBLOCK [62:25]
+    |       |--LCURLY -> { [62:25]
+    |       |--METHOD_DEF -> METHOD_DEF [63:8]
+    |       |   |--MODIFIERS -> MODIFIERS [63:8]
+    |       |   |--TYPE -> TYPE [63:8]
+    |       |   |   `--LITERAL_VOID -> void [63:8]
+    |       |   |--IDENT -> display [63:13]
+    |       |   |--LPAREN -> ( [63:20]
+    |       |   |--PARAMETERS -> PARAMETERS [63:21]
+    |       |   |--RPAREN -> ) [63:21]
+    |       |   `--SEMI -> ; [63:22]
+    |       |--INTERFACE_DEF -> INTERFACE_DEF [64:8]
+    |       |   |--MODIFIERS -> MODIFIERS [64:8]
+    |       |   |--LITERAL_INTERFACE -> interface [64:8]
+    |       |   |--IDENT -> Interface4 [64:18]
+    |       |   `--OBJBLOCK -> OBJBLOCK [64:29]
+    |       |       |--LCURLY -> { [64:29]
+    |       |       |--METHOD_DEF -> METHOD_DEF [65:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [65:12]
+    |       |       |   |--TYPE -> TYPE [65:12]
+    |       |       |   |   `--LITERAL_VOID -> void [65:12]
+    |       |       |   |--IDENT -> myMethod [65:17]
+    |       |       |   |--LPAREN -> ( [65:25]
+    |       |       |   |--PARAMETERS -> PARAMETERS [65:26]
+    |       |       |   |--RPAREN -> ) [65:26]
+    |       |       |   `--SEMI -> ; [65:27]
+    |       |       `--RCURLY -> } [66:8]
+    |       |--SEMI -> ; [66:9]
+    |       `--RCURLY -> } [66:10]
+    |--SEMI -> ; [66:11]
+    |--INTERFACE_DEF -> INTERFACE_DEF [68:4]
+    |   |--MODIFIERS -> MODIFIERS [68:4]
+    |   |--LITERAL_INTERFACE -> interface [68:4]
+    |   |--IDENT -> InterfaceEndingWithSemiColon2 [68:14]
+    |   `--OBJBLOCK -> OBJBLOCK [68:44]
+    |       |--LCURLY -> { [68:44]
+    |       |--METHOD_DEF -> METHOD_DEF [69:8]
+    |       |   |--MODIFIERS -> MODIFIERS [69:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [69:8]
+    |       |   |--TYPE -> TYPE [69:15]
+    |       |   |   `--LITERAL_VOID -> void [69:15]
+    |       |   |--IDENT -> fooEmpty [69:20]
+    |       |   |--LPAREN -> ( [69:28]
+    |       |   |--PARAMETERS -> PARAMETERS [69:29]
+    |       |   |--RPAREN -> ) [69:29]
+    |       |   `--SEMI -> ; [69:30]
+    |       `--RCURLY -> } [70:4]
+    |--SEMI -> ; [70:5]
+    `--RCURLY -> } [71:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSuppressWarnings.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSuppressWarnings.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSuppressWarnings.java
@@ -0,0 +1,49 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+import java.util.List;
+import java.util.Map;
+
+public class InputAntlr4AstRegressionSuppressWarnings {
+
+    public static Object foo1(@SuppressWarnings("unused") Object str) {
+        String myString = (@SuppressWarnings("unused") String) str;
+        Object object = new @SuppressWarnings("unused") Object();
+        try {
+            return null;
+
+        } catch (@SuppressWarnings("unused") Exception ex) {
+            return "";
+        }
+    }
+
+    void foo2() throws @SuppressWarnings("unused") Exception {  }
+
+    public void foo3() {
+        Map.@SuppressWarnings("unused") Entry entry;
+        MyObject myObject = new MyObject();
+        myObject.<@SuppressWarnings("unused") String>myMethod();
+        myObject.new @SuppressWarnings("unused") MyObject2();
+    }
+
+    public static <T> void foo4(Object str) {
+        List<@SuppressWarnings("unused") ? extends Comparable<T>> unchangeable;
+    }
+
+    abstract class UnmodifiableList<T>
+    implements @SuppressWarnings("unused")List<@SuppressWarnings("unused") T> {
+    }
+
+    class MyObject{
+
+        public void myMethod(){};
+
+        class MyObject2{}
+    }
+
+    @Target(ElementType.TYPE_USE)
+    @interface SuppressWarnings {
+        String value();
+    }
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSuppressWarnings.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSuppressWarnings.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionSuppressWarnings.txt
@@ -0,0 +1,381 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+IMPORT -> import [3:0]
+|--DOT -> . [3:27]
+|   |--DOT -> . [3:16]
+|   |   |--DOT -> . [3:11]
+|   |   |   |--IDENT -> java [3:7]
+|   |   |   `--IDENT -> lang [3:12]
+|   |   `--IDENT -> annotation [3:17]
+|   `--IDENT -> ElementType [3:28]
+`--SEMI -> ; [3:39]
+IMPORT -> import [4:0]
+|--DOT -> . [4:27]
+|   |--DOT -> . [4:16]
+|   |   |--DOT -> . [4:11]
+|   |   |   |--IDENT -> java [4:7]
+|   |   |   `--IDENT -> lang [4:12]
+|   |   `--IDENT -> annotation [4:17]
+|   `--IDENT -> Target [4:28]
+`--SEMI -> ; [4:34]
+IMPORT -> import [5:0]
+|--DOT -> . [5:16]
+|   |--DOT -> . [5:11]
+|   |   |--IDENT -> java [5:7]
+|   |   `--IDENT -> util [5:12]
+|   `--IDENT -> List [5:17]
+`--SEMI -> ; [5:21]
+IMPORT -> import [6:0]
+|--DOT -> . [6:16]
+|   |--DOT -> . [6:11]
+|   |   |--IDENT -> java [6:7]
+|   |   `--IDENT -> util [6:12]
+|   `--IDENT -> Map [6:17]
+`--SEMI -> ; [6:20]
+CLASS_DEF -> CLASS_DEF [8:0]
+|--MODIFIERS -> MODIFIERS [8:0]
+|   `--LITERAL_PUBLIC -> public [8:0]
+|--LITERAL_CLASS -> class [8:7]
+|--IDENT -> InputAntlr4AstRegressionSuppressWarnings [8:13]
+`--OBJBLOCK -> OBJBLOCK [8:54]
+    |--LCURLY -> { [8:54]
+    |--METHOD_DEF -> METHOD_DEF [10:4]
+    |   |--MODIFIERS -> MODIFIERS [10:4]
+    |   |   |--LITERAL_PUBLIC -> public [10:4]
+    |   |   `--LITERAL_STATIC -> static [10:11]
+    |   |--TYPE -> TYPE [10:18]
+    |   |   `--IDENT -> Object [10:18]
+    |   |--IDENT -> foo1 [10:25]
+    |   |--LPAREN -> ( [10:29]
+    |   |--PARAMETERS -> PARAMETERS [10:30]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [10:30]
+    |   |       |--MODIFIERS -> MODIFIERS [10:30]
+    |   |       |   `--ANNOTATION -> ANNOTATION [10:30]
+    |   |       |       |--AT -> @ [10:30]
+    |   |       |       |--IDENT -> SuppressWarnings [10:31]
+    |   |       |       |--LPAREN -> ( [10:47]
+    |   |       |       |--EXPR -> EXPR [10:48]
+    |   |       |       |   `--STRING_LITERAL -> "unused" [10:48]
+    |   |       |       `--RPAREN -> ) [10:56]
+    |   |       |--TYPE -> TYPE [10:58]
+    |   |       |   `--IDENT -> Object [10:58]
+    |   |       `--IDENT -> str [10:65]
+    |   |--RPAREN -> ) [10:68]
+    |   `--SLIST -> { [10:70]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [11:8]
+    |       |   |--MODIFIERS -> MODIFIERS [11:8]
+    |       |   |--TYPE -> TYPE [11:8]
+    |       |   |   `--IDENT -> String [11:8]
+    |       |   |--IDENT -> myString [11:15]
+    |       |   `--ASSIGN -> = [11:24]
+    |       |       `--EXPR -> EXPR [11:26]
+    |       |           `--TYPECAST -> ( [11:26]
+    |       |               |--TYPE -> TYPE [11:27]
+    |       |               |   |--ANNOTATIONS -> ANNOTATIONS [11:27]
+    |       |               |   |   `--ANNOTATION -> ANNOTATION [11:27]
+    |       |               |   |       |--AT -> @ [11:27]
+    |       |               |   |       |--IDENT -> SuppressWarnings [11:28]
+    |       |               |   |       |--LPAREN -> ( [11:44]
+    |       |               |   |       |--EXPR -> EXPR [11:45]
+    |       |               |   |       |   `--STRING_LITERAL -> "unused" [11:45]
+    |       |               |   |       `--RPAREN -> ) [11:53]
+    |       |               |   `--IDENT -> String [11:55]
+    |       |               |--RPAREN -> ) [11:61]
+    |       |               `--IDENT -> str [11:63]
+    |       |--SEMI -> ; [11:66]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [12:8]
+    |       |   |--MODIFIERS -> MODIFIERS [12:8]
+    |       |   |--TYPE -> TYPE [12:8]
+    |       |   |   `--IDENT -> Object [12:8]
+    |       |   |--IDENT -> object [12:15]
+    |       |   `--ASSIGN -> = [12:22]
+    |       |       `--EXPR -> EXPR [12:24]
+    |       |           `--LITERAL_NEW -> new [12:24]
+    |       |               |--ANNOTATIONS -> ANNOTATIONS [12:28]
+    |       |               |   `--ANNOTATION -> ANNOTATION [12:28]
+    |       |               |       |--AT -> @ [12:28]
+    |       |               |       |--IDENT -> SuppressWarnings [12:29]
+    |       |               |       |--LPAREN -> ( [12:45]
+    |       |               |       |--EXPR -> EXPR [12:46]
+    |       |               |       |   `--STRING_LITERAL -> "unused" [12:46]
+    |       |               |       `--RPAREN -> ) [12:54]
+    |       |               |--IDENT -> Object [12:56]
+    |       |               |--LPAREN -> ( [12:62]
+    |       |               |--ELIST -> ELIST [12:63]
+    |       |               `--RPAREN -> ) [12:63]
+    |       |--SEMI -> ; [12:64]
+    |       |--LITERAL_TRY -> try [13:8]
+    |       |   |--SLIST -> { [13:12]
+    |       |   |   |--LITERAL_RETURN -> return [14:12]
+    |       |   |   |   |--EXPR -> EXPR [14:19]
+    |       |   |   |   |   `--LITERAL_NULL -> null [14:19]
+    |       |   |   |   `--SEMI -> ; [14:23]
+    |       |   |   `--RCURLY -> } [16:8]
+    |       |   `--LITERAL_CATCH -> catch [16:10]
+    |       |       |--LPAREN -> ( [16:16]
+    |       |       |--PARAMETER_DEF -> PARAMETER_DEF [16:17]
+    |       |       |   |--MODIFIERS -> MODIFIERS [16:17]
+    |       |       |   |   `--ANNOTATION -> ANNOTATION [16:17]
+    |       |       |   |       |--AT -> @ [16:17]
+    |       |       |   |       |--IDENT -> SuppressWarnings [16:18]
+    |       |       |   |       |--LPAREN -> ( [16:34]
+    |       |       |   |       |--EXPR -> EXPR [16:35]
+    |       |       |   |       |   `--STRING_LITERAL -> "unused" [16:35]
+    |       |       |   |       `--RPAREN -> ) [16:43]
+    |       |       |   |--TYPE -> TYPE [16:45]
+    |       |       |   |   `--IDENT -> Exception [16:45]
+    |       |       |   `--IDENT -> ex [16:55]
+    |       |       |--RPAREN -> ) [16:57]
+    |       |       `--SLIST -> { [16:59]
+    |       |           |--LITERAL_RETURN -> return [17:12]
+    |       |           |   |--EXPR -> EXPR [17:19]
+    |       |           |   |   `--STRING_LITERAL -> "" [17:19]
+    |       |           |   `--SEMI -> ; [17:21]
+    |       |           `--RCURLY -> } [18:8]
+    |       `--RCURLY -> } [19:4]
+    |--METHOD_DEF -> METHOD_DEF [21:4]
+    |   |--MODIFIERS -> MODIFIERS [21:4]
+    |   |--TYPE -> TYPE [21:4]
+    |   |   `--LITERAL_VOID -> void [21:4]
+    |   |--IDENT -> foo2 [21:9]
+    |   |--LPAREN -> ( [21:13]
+    |   |--PARAMETERS -> PARAMETERS [21:14]
+    |   |--RPAREN -> ) [21:14]
+    |   |--LITERAL_THROWS -> throws [21:16]
+    |   |   |--ANNOTATIONS -> ANNOTATIONS [21:23]
+    |   |   |   `--ANNOTATION -> ANNOTATION [21:23]
+    |   |   |       |--AT -> @ [21:23]
+    |   |   |       |--IDENT -> SuppressWarnings [21:24]
+    |   |   |       |--LPAREN -> ( [21:40]
+    |   |   |       |--EXPR -> EXPR [21:41]
+    |   |   |       |   `--STRING_LITERAL -> "unused" [21:41]
+    |   |   |       `--RPAREN -> ) [21:49]
+    |   |   `--IDENT -> Exception [21:51]
+    |   `--SLIST -> { [21:61]
+    |       `--RCURLY -> } [21:64]
+    |--METHOD_DEF -> METHOD_DEF [23:4]
+    |   |--MODIFIERS -> MODIFIERS [23:4]
+    |   |   `--LITERAL_PUBLIC -> public [23:4]
+    |   |--TYPE -> TYPE [23:11]
+    |   |   `--LITERAL_VOID -> void [23:11]
+    |   |--IDENT -> foo3 [23:16]
+    |   |--LPAREN -> ( [23:20]
+    |   |--PARAMETERS -> PARAMETERS [23:21]
+    |   |--RPAREN -> ) [23:21]
+    |   `--SLIST -> { [23:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [24:11]
+    |       |   |--MODIFIERS -> MODIFIERS [24:11]
+    |       |   |--TYPE -> TYPE [24:11]
+    |       |   |   `--DOT -> . [24:11]
+    |       |   |       |--IDENT -> Map [24:8]
+    |       |   |       |--ANNOTATIONS -> ANNOTATIONS [24:12]
+    |       |   |       |   `--ANNOTATION -> ANNOTATION [24:12]
+    |       |   |       |       |--AT -> @ [24:12]
+    |       |   |       |       |--IDENT -> SuppressWarnings [24:13]
+    |       |   |       |       |--LPAREN -> ( [24:29]
+    |       |   |       |       |--EXPR -> EXPR [24:30]
+    |       |   |       |       |   `--STRING_LITERAL -> "unused" [24:30]
+    |       |   |       |       `--RPAREN -> ) [24:38]
+    |       |   |       `--IDENT -> Entry [24:40]
+    |       |   `--IDENT -> entry [24:46]
+    |       |--SEMI -> ; [24:51]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [25:8]
+    |       |   |--MODIFIERS -> MODIFIERS [25:8]
+    |       |   |--TYPE -> TYPE [25:8]
+    |       |   |   `--IDENT -> MyObject [25:8]
+    |       |   |--IDENT -> myObject [25:17]
+    |       |   `--ASSIGN -> = [25:26]
+    |       |       `--EXPR -> EXPR [25:28]
+    |       |           `--LITERAL_NEW -> new [25:28]
+    |       |               |--IDENT -> MyObject [25:32]
+    |       |               |--LPAREN -> ( [25:40]
+    |       |               |--ELIST -> ELIST [25:41]
+    |       |               `--RPAREN -> ) [25:41]
+    |       |--SEMI -> ; [25:42]
+    |       |--EXPR -> EXPR [26:61]
+    |       |   `--METHOD_CALL -> ( [26:61]
+    |       |       |--DOT -> . [26:16]
+    |       |       |   |--IDENT -> myObject [26:8]
+    |       |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [26:17]
+    |       |       |   |   |--GENERIC_START -> < [26:17]
+    |       |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [26:18]
+    |       |       |   |   |   |--ANNOTATIONS -> ANNOTATIONS [26:18]
+    |       |       |   |   |   |   `--ANNOTATION -> ANNOTATION [26:18]
+    |       |       |   |   |   |       |--AT -> @ [26:18]
+    |       |       |   |   |   |       |--IDENT -> SuppressWarnings [26:19]
+    |       |       |   |   |   |       |--LPAREN -> ( [26:35]
+    |       |       |   |   |   |       |--EXPR -> EXPR [26:36]
+    |       |       |   |   |   |       |   `--STRING_LITERAL -> "unused" [26:36]
+    |       |       |   |   |   |       `--RPAREN -> ) [26:44]
+    |       |       |   |   |   `--IDENT -> String [26:46]
+    |       |       |   |   `--GENERIC_END -> > [26:52]
+    |       |       |   `--IDENT -> myMethod [26:53]
+    |       |       |--ELIST -> ELIST [26:62]
+    |       |       `--RPAREN -> ) [26:62]
+    |       |--SEMI -> ; [26:63]
+    |       |--EXPR -> EXPR [27:16]
+    |       |   `--DOT -> . [27:16]
+    |       |       |--IDENT -> myObject [27:8]
+    |       |       `--LITERAL_NEW -> new [27:17]
+    |       |           |--ANNOTATIONS -> ANNOTATIONS [27:21]
+    |       |           |   `--ANNOTATION -> ANNOTATION [27:21]
+    |       |           |       |--AT -> @ [27:21]
+    |       |           |       |--IDENT -> SuppressWarnings [27:22]
+    |       |           |       |--LPAREN -> ( [27:38]
+    |       |           |       |--EXPR -> EXPR [27:39]
+    |       |           |       |   `--STRING_LITERAL -> "unused" [27:39]
+    |       |           |       `--RPAREN -> ) [27:47]
+    |       |           |--IDENT -> MyObject2 [27:49]
+    |       |           |--LPAREN -> ( [27:58]
+    |       |           |--ELIST -> ELIST [27:59]
+    |       |           `--RPAREN -> ) [27:59]
+    |       |--SEMI -> ; [27:60]
+    |       `--RCURLY -> } [28:4]
+    |--METHOD_DEF -> METHOD_DEF [30:4]
+    |   |--MODIFIERS -> MODIFIERS [30:4]
+    |   |   |--LITERAL_PUBLIC -> public [30:4]
+    |   |   `--LITERAL_STATIC -> static [30:11]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [30:18]
+    |   |   |--GENERIC_START -> < [30:18]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [30:19]
+    |   |   |   `--IDENT -> T [30:19]
+    |   |   `--GENERIC_END -> > [30:20]
+    |   |--TYPE -> TYPE [30:22]
+    |   |   `--LITERAL_VOID -> void [30:22]
+    |   |--IDENT -> foo4 [30:27]
+    |   |--LPAREN -> ( [30:31]
+    |   |--PARAMETERS -> PARAMETERS [30:32]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [30:32]
+    |   |       |--MODIFIERS -> MODIFIERS [30:32]
+    |   |       |--TYPE -> TYPE [30:32]
+    |   |       |   `--IDENT -> Object [30:32]
+    |   |       `--IDENT -> str [30:39]
+    |   |--RPAREN -> ) [30:42]
+    |   `--SLIST -> { [30:44]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [31:8]
+    |       |   |--MODIFIERS -> MODIFIERS [31:8]
+    |       |   |--TYPE -> TYPE [31:8]
+    |       |   |   |--IDENT -> List [31:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:12]
+    |       |   |       |--GENERIC_START -> < [31:12]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:13]
+    |       |   |       |   |--ANNOTATIONS -> ANNOTATIONS [31:13]
+    |       |   |       |   |   `--ANNOTATION -> ANNOTATION [31:13]
+    |       |   |       |   |       |--AT -> @ [31:13]
+    |       |   |       |   |       |--IDENT -> SuppressWarnings [31:14]
+    |       |   |       |   |       |--LPAREN -> ( [31:30]
+    |       |   |       |   |       |--EXPR -> EXPR [31:31]
+    |       |   |       |   |       |   `--STRING_LITERAL -> "unused" [31:31]
+    |       |   |       |   |       `--RPAREN -> ) [31:39]
+    |       |   |       |   |--WILDCARD_TYPE -> ? [31:41]
+    |       |   |       |   `--TYPE_UPPER_BOUNDS -> extends [31:43]
+    |       |   |       |       |--IDENT -> Comparable [31:51]
+    |       |   |       |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:61]
+    |       |   |       |           |--GENERIC_START -> < [31:61]
+    |       |   |       |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:62]
+    |       |   |       |           |   `--IDENT -> T [31:62]
+    |       |   |       |           `--GENERIC_END -> > [31:63]
+    |       |   |       `--GENERIC_END -> > [31:64]
+    |       |   `--IDENT -> unchangeable [31:66]
+    |       |--SEMI -> ; [31:78]
+    |       `--RCURLY -> } [32:4]
+    |--CLASS_DEF -> CLASS_DEF [34:4]
+    |   |--MODIFIERS -> MODIFIERS [34:4]
+    |   |   `--ABSTRACT -> abstract [34:4]
+    |   |--LITERAL_CLASS -> class [34:13]
+    |   |--IDENT -> UnmodifiableList [34:19]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [34:35]
+    |   |   |--GENERIC_START -> < [34:35]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [34:36]
+    |   |   |   `--IDENT -> T [34:36]
+    |   |   `--GENERIC_END -> > [34:37]
+    |   |--IMPLEMENTS_CLAUSE -> implements [35:4]
+    |   |   |--ANNOTATIONS -> ANNOTATIONS [35:15]
+    |   |   |   `--ANNOTATION -> ANNOTATION [35:15]
+    |   |   |       |--AT -> @ [35:15]
+    |   |   |       |--IDENT -> SuppressWarnings [35:16]
+    |   |   |       |--LPAREN -> ( [35:32]
+    |   |   |       |--EXPR -> EXPR [35:33]
+    |   |   |       |   `--STRING_LITERAL -> "unused" [35:33]
+    |   |   |       `--RPAREN -> ) [35:41]
+    |   |   |--IDENT -> List [35:42]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [35:46]
+    |   |       |--GENERIC_START -> < [35:46]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [35:47]
+    |   |       |   |--ANNOTATIONS -> ANNOTATIONS [35:47]
+    |   |       |   |   `--ANNOTATION -> ANNOTATION [35:47]
+    |   |       |   |       |--AT -> @ [35:47]
+    |   |       |   |       |--IDENT -> SuppressWarnings [35:48]
+    |   |       |   |       |--LPAREN -> ( [35:64]
+    |   |       |   |       |--EXPR -> EXPR [35:65]
+    |   |       |   |       |   `--STRING_LITERAL -> "unused" [35:65]
+    |   |       |   |       `--RPAREN -> ) [35:73]
+    |   |       |   `--IDENT -> T [35:75]
+    |   |       `--GENERIC_END -> > [35:76]
+    |   `--OBJBLOCK -> OBJBLOCK [35:78]
+    |       |--LCURLY -> { [35:78]
+    |       `--RCURLY -> } [36:4]
+    |--CLASS_DEF -> CLASS_DEF [38:4]
+    |   |--MODIFIERS -> MODIFIERS [38:4]
+    |   |--LITERAL_CLASS -> class [38:4]
+    |   |--IDENT -> MyObject [38:10]
+    |   `--OBJBLOCK -> OBJBLOCK [38:18]
+    |       |--LCURLY -> { [38:18]
+    |       |--METHOD_DEF -> METHOD_DEF [40:8]
+    |       |   |--MODIFIERS -> MODIFIERS [40:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [40:8]
+    |       |   |--TYPE -> TYPE [40:15]
+    |       |   |   `--LITERAL_VOID -> void [40:15]
+    |       |   |--IDENT -> myMethod [40:20]
+    |       |   |--LPAREN -> ( [40:28]
+    |       |   |--PARAMETERS -> PARAMETERS [40:29]
+    |       |   |--RPAREN -> ) [40:29]
+    |       |   `--SLIST -> { [40:30]
+    |       |       `--RCURLY -> } [40:31]
+    |       |--SEMI -> ; [40:32]
+    |       |--CLASS_DEF -> CLASS_DEF [42:8]
+    |       |   |--MODIFIERS -> MODIFIERS [42:8]
+    |       |   |--LITERAL_CLASS -> class [42:8]
+    |       |   |--IDENT -> MyObject2 [42:14]
+    |       |   `--OBJBLOCK -> OBJBLOCK [42:23]
+    |       |       |--LCURLY -> { [42:23]
+    |       |       `--RCURLY -> } [42:24]
+    |       `--RCURLY -> } [43:4]
+    |--ANNOTATION_DEF -> ANNOTATION_DEF [45:4]
+    |   |--MODIFIERS -> MODIFIERS [45:4]
+    |   |   `--ANNOTATION -> ANNOTATION [45:4]
+    |   |       |--AT -> @ [45:4]
+    |   |       |--IDENT -> Target [45:5]
+    |   |       |--LPAREN -> ( [45:11]
+    |   |       |--EXPR -> EXPR [45:23]
+    |   |       |   `--DOT -> . [45:23]
+    |   |       |       |--IDENT -> ElementType [45:12]
+    |   |       |       `--IDENT -> TYPE_USE [45:24]
+    |   |       `--RPAREN -> ) [45:32]
+    |   |--AT -> @ [46:4]
+    |   |--LITERAL_INTERFACE -> interface [46:5]
+    |   |--IDENT -> SuppressWarnings [46:15]
+    |   `--OBJBLOCK -> OBJBLOCK [46:32]
+    |       |--LCURLY -> { [46:32]
+    |       |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [47:8]
+    |       |   |--MODIFIERS -> MODIFIERS [47:8]
+    |       |   |--TYPE -> TYPE [47:8]
+    |       |   |   `--IDENT -> String [47:8]
+    |       |   |--IDENT -> value [47:15]
+    |       |   |--LPAREN -> ( [47:20]
+    |       |   |--RPAREN -> ) [47:21]
+    |       |   `--SEMI -> ; [47:22]
+    |       `--RCURLY -> } [48:4]
+    `--RCURLY -> } [49:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickySwitch.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickySwitch.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickySwitch.java
@@ -0,0 +1,268 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+public class InputAntlr4AstRegressionTrickySwitch {
+
+    private static void fooSwitch() {
+        switch("") {
+            case "0": //some comment
+            case "1":
+                // my comment
+                foo1();
+                break;
+            case "2":
+                // my comment
+                //comment
+                foo1();
+                // comment
+                break;
+            case "3":
+            /* // warn */
+                foo1();
+                /* com */
+                break;
+            case "5":
+                foo1();
+                   // warn
+            case "6":
+                int k = 7;
+                // fall through
+            case "7":
+                if (true) {}
+                   // warn
+            case "8":
+                break;
+            case "9":
+                foo1();
+                // fall through
+            case "10": {
+                if (true) {}
+                // fall through
+            }
+            case "11": {
+            // fall through
+            }
+            case "28": {
+                // fall through
+            }
+            case "12": {
+      // warn
+                int i;
+            }
+            case "13": {
+                       // some comment in empty case block
+            }
+            case "14": {
+        // warn
+            }
+            case "15": {
+                foo1();
+                      // warn
+            }
+            case "16": {
+                int a;
+            }
+            // fall through
+            case "17": {
+                int a;
+            }
+              // warn
+                case "18": { System.lineSeparator();
+                }   // trailing comment
+            case "19":
+                // comment
+            case "20":
+            // comment
+            case "21":
+            default:
+                // comment
+                break;
+        }
+    }
+
+    private static void foo1() {
+        if (true) {
+            switch(1) {
+                case 0:
+
+                case 1:
+                        // warn
+                    int b = 10;
+                default:
+                 // comment
+            }
+
+        }
+    }
+
+    public void fooDotInCaseBlock() {
+        int i = 0;
+        String s = "";
+
+        switch (i) {
+            case -2:
+                // what
+                i++;
+                // no break here
+            case 0:
+                // what
+                s.indexOf("ignore");
+                // no break here
+            case -1:
+                 // what
+                 s.indexOf("no way");
+               // warn
+            case 1:
+            case 2:
+                i--;
+                // no break here
+            case 3: { }
+            // fall through
+
+
+        }
+
+        String breaks = ""
+        // warn
+            + "</table>"
+            // middle
+            + ""
+        // end
+        ;
+    }
+
+    public void foo2() {
+        int a = 1;
+        switch (a) {
+            case 1:
+            default:
+    // warn
+        }
+    }
+
+    public void foo3() {
+        int a = 1;
+        switch (a) {
+            case 1:
+            default:
+
+                // comment
+        }
+    }
+
+    public void foo4() {
+        int a = 1;
+        switch (a) {
+            case 1:
+                int b;
+                  // warn
+            default:
+        }
+    }
+
+    public void foo5() {
+        int a = 1;
+        switch (a) {
+            case 1:
+                int b;
+            // comment
+            default:
+        }
+    }
+
+    public void foo6() {
+        int a = 1;
+        switch (a) {
+            case 1:
+                int b;
+                // comment
+            default:
+        }
+    }
+
+    public void foo7() {
+        int a = 2;
+        String s = "";
+        switch (a) {
+            // comment
+            // comment
+            // comment
+            case 1:
+            case 2:
+                // comment
+                // comment
+                foo1();
+                // comment
+            case 3:
+                // comment
+                // comment
+                // comment
+            case 4:
+    // warn
+            case 5:
+                s.toString().toString().toString();
+                      // warn
+                    // warn
+                 // warn
+            default:
+        }
+    }
+
+    public void foo8() {
+        int a = 2;
+        String s = "";
+        switch (a) {
+            // comment
+            // comment
+            // comment
+            case 1:
+            case 2:
+                // comment
+                // comment
+                foo1();
+                // comment
+            case 3:
+                // comment
+                // comment
+                s.toString().toString().toString();
+                // comment
+            case 4:
+      // warn
+            default:
+        }
+    }
+
+    public void foo9() {
+        int a = 5;
+        switch (a) {
+            case 1:
+            case 2:
+                // comment
+        }
+    }
+
+    public void foo10() {
+        int a = 5;
+        switch (a) {
+            case 1:
+            default:
+                // comment
+        }
+    }
+
+    public void foo11() {
+        int a = 5;
+        switch (a) {
+            case 1:
+            case 2:
+                // comment
+        }
+    }
+
+    public void foo12() {
+        int a = 5;
+        switch (a) {
+            // comment
+            case 1:
+        }
+    }
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickySwitch.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickySwitch.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickySwitch.txt
@@ -0,0 +1,949 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+CLASS_DEF -> CLASS_DEF [3:0]
+|--MODIFIERS -> MODIFIERS [3:0]
+|   `--LITERAL_PUBLIC -> public [3:0]
+|--LITERAL_CLASS -> class [3:7]
+|--IDENT -> InputAntlr4AstRegressionTrickySwitch [3:13]
+`--OBJBLOCK -> OBJBLOCK [3:50]
+    |--LCURLY -> { [3:50]
+    |--METHOD_DEF -> METHOD_DEF [5:4]
+    |   |--MODIFIERS -> MODIFIERS [5:4]
+    |   |   |--LITERAL_PRIVATE -> private [5:4]
+    |   |   `--LITERAL_STATIC -> static [5:12]
+    |   |--TYPE -> TYPE [5:19]
+    |   |   `--LITERAL_VOID -> void [5:19]
+    |   |--IDENT -> fooSwitch [5:24]
+    |   |--LPAREN -> ( [5:33]
+    |   |--PARAMETERS -> PARAMETERS [5:34]
+    |   |--RPAREN -> ) [5:34]
+    |   `--SLIST -> { [5:36]
+    |       |--LITERAL_SWITCH -> switch [6:8]
+    |       |   |--LPAREN -> ( [6:14]
+    |       |   |--EXPR -> EXPR [6:15]
+    |       |   |   `--STRING_LITERAL -> "" [6:15]
+    |       |   |--RPAREN -> ) [6:17]
+    |       |   |--LCURLY -> { [6:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [7:12]
+    |       |   |   |--LITERAL_CASE -> case [7:12]
+    |       |   |   |   |--EXPR -> EXPR [7:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "0" [7:17]
+    |       |   |   |   `--COLON -> : [7:20]
+    |       |   |   |--LITERAL_CASE -> case [8:12]
+    |       |   |   |   |--EXPR -> EXPR [8:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "1" [8:17]
+    |       |   |   |   `--COLON -> : [8:20]
+    |       |   |   `--SLIST -> SLIST [10:20]
+    |       |   |       |--EXPR -> EXPR [10:20]
+    |       |   |       |   `--METHOD_CALL -> ( [10:20]
+    |       |   |       |       |--IDENT -> foo1 [10:16]
+    |       |   |       |       |--ELIST -> ELIST [10:21]
+    |       |   |       |       `--RPAREN -> ) [10:21]
+    |       |   |       |--SEMI -> ; [10:22]
+    |       |   |       `--LITERAL_BREAK -> break [11:16]
+    |       |   |           `--SEMI -> ; [11:21]
+    |       |   |--CASE_GROUP -> CASE_GROUP [12:12]
+    |       |   |   |--LITERAL_CASE -> case [12:12]
+    |       |   |   |   |--EXPR -> EXPR [12:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "2" [12:17]
+    |       |   |   |   `--COLON -> : [12:20]
+    |       |   |   `--SLIST -> SLIST [15:20]
+    |       |   |       |--EXPR -> EXPR [15:20]
+    |       |   |       |   `--METHOD_CALL -> ( [15:20]
+    |       |   |       |       |--IDENT -> foo1 [15:16]
+    |       |   |       |       |--ELIST -> ELIST [15:21]
+    |       |   |       |       `--RPAREN -> ) [15:21]
+    |       |   |       |--SEMI -> ; [15:22]
+    |       |   |       `--LITERAL_BREAK -> break [17:16]
+    |       |   |           `--SEMI -> ; [17:21]
+    |       |   |--CASE_GROUP -> CASE_GROUP [18:12]
+    |       |   |   |--LITERAL_CASE -> case [18:12]
+    |       |   |   |   |--EXPR -> EXPR [18:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "3" [18:17]
+    |       |   |   |   `--COLON -> : [18:20]
+    |       |   |   `--SLIST -> SLIST [20:20]
+    |       |   |       |--EXPR -> EXPR [20:20]
+    |       |   |       |   `--METHOD_CALL -> ( [20:20]
+    |       |   |       |       |--IDENT -> foo1 [20:16]
+    |       |   |       |       |--ELIST -> ELIST [20:21]
+    |       |   |       |       `--RPAREN -> ) [20:21]
+    |       |   |       |--SEMI -> ; [20:22]
+    |       |   |       `--LITERAL_BREAK -> break [22:16]
+    |       |   |           `--SEMI -> ; [22:21]
+    |       |   |--CASE_GROUP -> CASE_GROUP [23:12]
+    |       |   |   |--LITERAL_CASE -> case [23:12]
+    |       |   |   |   |--EXPR -> EXPR [23:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "5" [23:17]
+    |       |   |   |   `--COLON -> : [23:20]
+    |       |   |   `--SLIST -> SLIST [24:20]
+    |       |   |       |--EXPR -> EXPR [24:20]
+    |       |   |       |   `--METHOD_CALL -> ( [24:20]
+    |       |   |       |       |--IDENT -> foo1 [24:16]
+    |       |   |       |       |--ELIST -> ELIST [24:21]
+    |       |   |       |       `--RPAREN -> ) [24:21]
+    |       |   |       `--SEMI -> ; [24:22]
+    |       |   |--CASE_GROUP -> CASE_GROUP [26:12]
+    |       |   |   |--LITERAL_CASE -> case [26:12]
+    |       |   |   |   |--EXPR -> EXPR [26:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "6" [26:17]
+    |       |   |   |   `--COLON -> : [26:20]
+    |       |   |   `--SLIST -> SLIST [27:16]
+    |       |   |       |--VARIABLE_DEF -> VARIABLE_DEF [27:16]
+    |       |   |       |   |--MODIFIERS -> MODIFIERS [27:16]
+    |       |   |       |   |--TYPE -> TYPE [27:16]
+    |       |   |       |   |   `--LITERAL_INT -> int [27:16]
+    |       |   |       |   |--IDENT -> k [27:20]
+    |       |   |       |   `--ASSIGN -> = [27:22]
+    |       |   |       |       `--EXPR -> EXPR [27:24]
+    |       |   |       |           `--NUM_INT -> 7 [27:24]
+    |       |   |       `--SEMI -> ; [27:25]
+    |       |   |--CASE_GROUP -> CASE_GROUP [29:12]
+    |       |   |   |--LITERAL_CASE -> case [29:12]
+    |       |   |   |   |--EXPR -> EXPR [29:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "7" [29:17]
+    |       |   |   |   `--COLON -> : [29:20]
+    |       |   |   `--SLIST -> SLIST [30:16]
+    |       |   |       `--LITERAL_IF -> if [30:16]
+    |       |   |           |--LPAREN -> ( [30:19]
+    |       |   |           |--EXPR -> EXPR [30:20]
+    |       |   |           |   `--LITERAL_TRUE -> true [30:20]
+    |       |   |           |--RPAREN -> ) [30:24]
+    |       |   |           `--SLIST -> { [30:26]
+    |       |   |               `--RCURLY -> } [30:27]
+    |       |   |--CASE_GROUP -> CASE_GROUP [32:12]
+    |       |   |   |--LITERAL_CASE -> case [32:12]
+    |       |   |   |   |--EXPR -> EXPR [32:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "8" [32:17]
+    |       |   |   |   `--COLON -> : [32:20]
+    |       |   |   `--SLIST -> SLIST [33:16]
+    |       |   |       `--LITERAL_BREAK -> break [33:16]
+    |       |   |           `--SEMI -> ; [33:21]
+    |       |   |--CASE_GROUP -> CASE_GROUP [34:12]
+    |       |   |   |--LITERAL_CASE -> case [34:12]
+    |       |   |   |   |--EXPR -> EXPR [34:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "9" [34:17]
+    |       |   |   |   `--COLON -> : [34:20]
+    |       |   |   `--SLIST -> SLIST [35:20]
+    |       |   |       |--EXPR -> EXPR [35:20]
+    |       |   |       |   `--METHOD_CALL -> ( [35:20]
+    |       |   |       |       |--IDENT -> foo1 [35:16]
+    |       |   |       |       |--ELIST -> ELIST [35:21]
+    |       |   |       |       `--RPAREN -> ) [35:21]
+    |       |   |       `--SEMI -> ; [35:22]
+    |       |   |--CASE_GROUP -> CASE_GROUP [37:12]
+    |       |   |   |--LITERAL_CASE -> case [37:12]
+    |       |   |   |   |--EXPR -> EXPR [37:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "10" [37:17]
+    |       |   |   |   `--COLON -> : [37:21]
+    |       |   |   `--SLIST -> SLIST [37:23]
+    |       |   |       `--SLIST -> { [37:23]
+    |       |   |           |--LITERAL_IF -> if [38:16]
+    |       |   |           |   |--LPAREN -> ( [38:19]
+    |       |   |           |   |--EXPR -> EXPR [38:20]
+    |       |   |           |   |   `--LITERAL_TRUE -> true [38:20]
+    |       |   |           |   |--RPAREN -> ) [38:24]
+    |       |   |           |   `--SLIST -> { [38:26]
+    |       |   |           |       `--RCURLY -> } [38:27]
+    |       |   |           `--RCURLY -> } [40:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [41:12]
+    |       |   |   |--LITERAL_CASE -> case [41:12]
+    |       |   |   |   |--EXPR -> EXPR [41:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "11" [41:17]
+    |       |   |   |   `--COLON -> : [41:21]
+    |       |   |   `--SLIST -> SLIST [41:23]
+    |       |   |       `--SLIST -> { [41:23]
+    |       |   |           `--RCURLY -> } [43:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [44:12]
+    |       |   |   |--LITERAL_CASE -> case [44:12]
+    |       |   |   |   |--EXPR -> EXPR [44:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "28" [44:17]
+    |       |   |   |   `--COLON -> : [44:21]
+    |       |   |   `--SLIST -> SLIST [44:23]
+    |       |   |       `--SLIST -> { [44:23]
+    |       |   |           `--RCURLY -> } [46:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [47:12]
+    |       |   |   |--LITERAL_CASE -> case [47:12]
+    |       |   |   |   |--EXPR -> EXPR [47:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "12" [47:17]
+    |       |   |   |   `--COLON -> : [47:21]
+    |       |   |   `--SLIST -> SLIST [47:23]
+    |       |   |       `--SLIST -> { [47:23]
+    |       |   |           |--VARIABLE_DEF -> VARIABLE_DEF [49:16]
+    |       |   |           |   |--MODIFIERS -> MODIFIERS [49:16]
+    |       |   |           |   |--TYPE -> TYPE [49:16]
+    |       |   |           |   |   `--LITERAL_INT -> int [49:16]
+    |       |   |           |   `--IDENT -> i [49:20]
+    |       |   |           |--SEMI -> ; [49:21]
+    |       |   |           `--RCURLY -> } [50:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [51:12]
+    |       |   |   |--LITERAL_CASE -> case [51:12]
+    |       |   |   |   |--EXPR -> EXPR [51:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "13" [51:17]
+    |       |   |   |   `--COLON -> : [51:21]
+    |       |   |   `--SLIST -> SLIST [51:23]
+    |       |   |       `--SLIST -> { [51:23]
+    |       |   |           `--RCURLY -> } [53:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [54:12]
+    |       |   |   |--LITERAL_CASE -> case [54:12]
+    |       |   |   |   |--EXPR -> EXPR [54:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "14" [54:17]
+    |       |   |   |   `--COLON -> : [54:21]
+    |       |   |   `--SLIST -> SLIST [54:23]
+    |       |   |       `--SLIST -> { [54:23]
+    |       |   |           `--RCURLY -> } [56:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [57:12]
+    |       |   |   |--LITERAL_CASE -> case [57:12]
+    |       |   |   |   |--EXPR -> EXPR [57:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "15" [57:17]
+    |       |   |   |   `--COLON -> : [57:21]
+    |       |   |   `--SLIST -> SLIST [57:23]
+    |       |   |       `--SLIST -> { [57:23]
+    |       |   |           |--EXPR -> EXPR [58:20]
+    |       |   |           |   `--METHOD_CALL -> ( [58:20]
+    |       |   |           |       |--IDENT -> foo1 [58:16]
+    |       |   |           |       |--ELIST -> ELIST [58:21]
+    |       |   |           |       `--RPAREN -> ) [58:21]
+    |       |   |           |--SEMI -> ; [58:22]
+    |       |   |           `--RCURLY -> } [60:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [61:12]
+    |       |   |   |--LITERAL_CASE -> case [61:12]
+    |       |   |   |   |--EXPR -> EXPR [61:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "16" [61:17]
+    |       |   |   |   `--COLON -> : [61:21]
+    |       |   |   `--SLIST -> SLIST [61:23]
+    |       |   |       `--SLIST -> { [61:23]
+    |       |   |           |--VARIABLE_DEF -> VARIABLE_DEF [62:16]
+    |       |   |           |   |--MODIFIERS -> MODIFIERS [62:16]
+    |       |   |           |   |--TYPE -> TYPE [62:16]
+    |       |   |           |   |   `--LITERAL_INT -> int [62:16]
+    |       |   |           |   `--IDENT -> a [62:20]
+    |       |   |           |--SEMI -> ; [62:21]
+    |       |   |           `--RCURLY -> } [63:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [65:12]
+    |       |   |   |--LITERAL_CASE -> case [65:12]
+    |       |   |   |   |--EXPR -> EXPR [65:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "17" [65:17]
+    |       |   |   |   `--COLON -> : [65:21]
+    |       |   |   `--SLIST -> SLIST [65:23]
+    |       |   |       `--SLIST -> { [65:23]
+    |       |   |           |--VARIABLE_DEF -> VARIABLE_DEF [66:16]
+    |       |   |           |   |--MODIFIERS -> MODIFIERS [66:16]
+    |       |   |           |   |--TYPE -> TYPE [66:16]
+    |       |   |           |   |   `--LITERAL_INT -> int [66:16]
+    |       |   |           |   `--IDENT -> a [66:20]
+    |       |   |           |--SEMI -> ; [66:21]
+    |       |   |           `--RCURLY -> } [67:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [69:16]
+    |       |   |   |--LITERAL_CASE -> case [69:16]
+    |       |   |   |   |--EXPR -> EXPR [69:21]
+    |       |   |   |   |   `--STRING_LITERAL -> "18" [69:21]
+    |       |   |   |   `--COLON -> : [69:25]
+    |       |   |   `--SLIST -> SLIST [69:27]
+    |       |   |       `--SLIST -> { [69:27]
+    |       |   |           |--EXPR -> EXPR [69:49]
+    |       |   |           |   `--METHOD_CALL -> ( [69:49]
+    |       |   |           |       |--DOT -> . [69:35]
+    |       |   |           |       |   |--IDENT -> System [69:29]
+    |       |   |           |       |   `--IDENT -> lineSeparator [69:36]
+    |       |   |           |       |--ELIST -> ELIST [69:50]
+    |       |   |           |       `--RPAREN -> ) [69:50]
+    |       |   |           |--SEMI -> ; [69:51]
+    |       |   |           `--RCURLY -> } [70:16]
+    |       |   |--CASE_GROUP -> CASE_GROUP [71:12]
+    |       |   |   |--LITERAL_CASE -> case [71:12]
+    |       |   |   |   |--EXPR -> EXPR [71:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "19" [71:17]
+    |       |   |   |   `--COLON -> : [71:21]
+    |       |   |   |--LITERAL_CASE -> case [73:12]
+    |       |   |   |   |--EXPR -> EXPR [73:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "20" [73:17]
+    |       |   |   |   `--COLON -> : [73:21]
+    |       |   |   |--LITERAL_CASE -> case [75:12]
+    |       |   |   |   |--EXPR -> EXPR [75:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "21" [75:17]
+    |       |   |   |   `--COLON -> : [75:21]
+    |       |   |   |--LITERAL_DEFAULT -> default [76:12]
+    |       |   |   |   `--COLON -> : [76:19]
+    |       |   |   `--SLIST -> SLIST [78:16]
+    |       |   |       `--LITERAL_BREAK -> break [78:16]
+    |       |   |           `--SEMI -> ; [78:21]
+    |       |   `--RCURLY -> } [79:8]
+    |       `--RCURLY -> } [80:4]
+    |--METHOD_DEF -> METHOD_DEF [82:4]
+    |   |--MODIFIERS -> MODIFIERS [82:4]
+    |   |   |--LITERAL_PRIVATE -> private [82:4]
+    |   |   `--LITERAL_STATIC -> static [82:12]
+    |   |--TYPE -> TYPE [82:19]
+    |   |   `--LITERAL_VOID -> void [82:19]
+    |   |--IDENT -> foo1 [82:24]
+    |   |--LPAREN -> ( [82:28]
+    |   |--PARAMETERS -> PARAMETERS [82:29]
+    |   |--RPAREN -> ) [82:29]
+    |   `--SLIST -> { [82:31]
+    |       |--LITERAL_IF -> if [83:8]
+    |       |   |--LPAREN -> ( [83:11]
+    |       |   |--EXPR -> EXPR [83:12]
+    |       |   |   `--LITERAL_TRUE -> true [83:12]
+    |       |   |--RPAREN -> ) [83:16]
+    |       |   `--SLIST -> { [83:18]
+    |       |       |--LITERAL_SWITCH -> switch [84:12]
+    |       |       |   |--LPAREN -> ( [84:18]
+    |       |       |   |--EXPR -> EXPR [84:19]
+    |       |       |   |   `--NUM_INT -> 1 [84:19]
+    |       |       |   |--RPAREN -> ) [84:20]
+    |       |       |   |--LCURLY -> { [84:22]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [85:16]
+    |       |       |   |   |--LITERAL_CASE -> case [85:16]
+    |       |       |   |   |   |--EXPR -> EXPR [85:21]
+    |       |       |   |   |   |   `--NUM_INT -> 0 [85:21]
+    |       |       |   |   |   `--COLON -> : [85:22]
+    |       |       |   |   |--LITERAL_CASE -> case [87:16]
+    |       |       |   |   |   |--EXPR -> EXPR [87:21]
+    |       |       |   |   |   |   `--NUM_INT -> 1 [87:21]
+    |       |       |   |   |   `--COLON -> : [87:22]
+    |       |       |   |   `--SLIST -> SLIST [89:20]
+    |       |       |   |       |--VARIABLE_DEF -> VARIABLE_DEF [89:20]
+    |       |       |   |       |   |--MODIFIERS -> MODIFIERS [89:20]
+    |       |       |   |       |   |--TYPE -> TYPE [89:20]
+    |       |       |   |       |   |   `--LITERAL_INT -> int [89:20]
+    |       |       |   |       |   |--IDENT -> b [89:24]
+    |       |       |   |       |   `--ASSIGN -> = [89:26]
+    |       |       |   |       |       `--EXPR -> EXPR [89:28]
+    |       |       |   |       |           `--NUM_INT -> 10 [89:28]
+    |       |       |   |       `--SEMI -> ; [89:30]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [90:16]
+    |       |       |   |   `--LITERAL_DEFAULT -> default [90:16]
+    |       |       |   |       `--COLON -> : [90:23]
+    |       |       |   `--RCURLY -> } [92:12]
+    |       |       `--RCURLY -> } [94:8]
+    |       `--RCURLY -> } [95:4]
+    |--METHOD_DEF -> METHOD_DEF [97:4]
+    |   |--MODIFIERS -> MODIFIERS [97:4]
+    |   |   `--LITERAL_PUBLIC -> public [97:4]
+    |   |--TYPE -> TYPE [97:11]
+    |   |   `--LITERAL_VOID -> void [97:11]
+    |   |--IDENT -> fooDotInCaseBlock [97:16]
+    |   |--LPAREN -> ( [97:33]
+    |   |--PARAMETERS -> PARAMETERS [97:34]
+    |   |--RPAREN -> ) [97:34]
+    |   `--SLIST -> { [97:36]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [98:8]
+    |       |   |--MODIFIERS -> MODIFIERS [98:8]
+    |       |   |--TYPE -> TYPE [98:8]
+    |       |   |   `--LITERAL_INT -> int [98:8]
+    |       |   |--IDENT -> i [98:12]
+    |       |   `--ASSIGN -> = [98:14]
+    |       |       `--EXPR -> EXPR [98:16]
+    |       |           `--NUM_INT -> 0 [98:16]
+    |       |--SEMI -> ; [98:17]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [99:8]
+    |       |   |--MODIFIERS -> MODIFIERS [99:8]
+    |       |   |--TYPE -> TYPE [99:8]
+    |       |   |   `--IDENT -> String [99:8]
+    |       |   |--IDENT -> s [99:15]
+    |       |   `--ASSIGN -> = [99:17]
+    |       |       `--EXPR -> EXPR [99:19]
+    |       |           `--STRING_LITERAL -> "" [99:19]
+    |       |--SEMI -> ; [99:21]
+    |       |--LITERAL_SWITCH -> switch [101:8]
+    |       |   |--LPAREN -> ( [101:15]
+    |       |   |--EXPR -> EXPR [101:16]
+    |       |   |   `--IDENT -> i [101:16]
+    |       |   |--RPAREN -> ) [101:17]
+    |       |   |--LCURLY -> { [101:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [102:12]
+    |       |   |   |--LITERAL_CASE -> case [102:12]
+    |       |   |   |   |--EXPR -> EXPR [102:17]
+    |       |   |   |   |   `--UNARY_MINUS -> - [102:17]
+    |       |   |   |   |       `--NUM_INT -> 2 [102:18]
+    |       |   |   |   `--COLON -> : [102:19]
+    |       |   |   `--SLIST -> SLIST [104:17]
+    |       |   |       |--EXPR -> EXPR [104:17]
+    |       |   |       |   `--POST_INC -> ++ [104:17]
+    |       |   |       |       `--IDENT -> i [104:16]
+    |       |   |       `--SEMI -> ; [104:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [106:12]
+    |       |   |   |--LITERAL_CASE -> case [106:12]
+    |       |   |   |   |--EXPR -> EXPR [106:17]
+    |       |   |   |   |   `--NUM_INT -> 0 [106:17]
+    |       |   |   |   `--COLON -> : [106:18]
+    |       |   |   `--SLIST -> SLIST [108:25]
+    |       |   |       |--EXPR -> EXPR [108:25]
+    |       |   |       |   `--METHOD_CALL -> ( [108:25]
+    |       |   |       |       |--DOT -> . [108:17]
+    |       |   |       |       |   |--IDENT -> s [108:16]
+    |       |   |       |       |   `--IDENT -> indexOf [108:18]
+    |       |   |       |       |--ELIST -> ELIST [108:26]
+    |       |   |       |       |   `--EXPR -> EXPR [108:26]
+    |       |   |       |       |       `--STRING_LITERAL -> "ignore" [108:26]
+    |       |   |       |       `--RPAREN -> ) [108:34]
+    |       |   |       `--SEMI -> ; [108:35]
+    |       |   |--CASE_GROUP -> CASE_GROUP [110:12]
+    |       |   |   |--LITERAL_CASE -> case [110:12]
+    |       |   |   |   |--EXPR -> EXPR [110:17]
+    |       |   |   |   |   `--UNARY_MINUS -> - [110:17]
+    |       |   |   |   |       `--NUM_INT -> 1 [110:18]
+    |       |   |   |   `--COLON -> : [110:19]
+    |       |   |   `--SLIST -> SLIST [112:26]
+    |       |   |       |--EXPR -> EXPR [112:26]
+    |       |   |       |   `--METHOD_CALL -> ( [112:26]
+    |       |   |       |       |--DOT -> . [112:18]
+    |       |   |       |       |   |--IDENT -> s [112:17]
+    |       |   |       |       |   `--IDENT -> indexOf [112:19]
+    |       |   |       |       |--ELIST -> ELIST [112:27]
+    |       |   |       |       |   `--EXPR -> EXPR [112:27]
+    |       |   |       |       |       `--STRING_LITERAL -> "no way" [112:27]
+    |       |   |       |       `--RPAREN -> ) [112:35]
+    |       |   |       `--SEMI -> ; [112:36]
+    |       |   |--CASE_GROUP -> CASE_GROUP [114:12]
+    |       |   |   |--LITERAL_CASE -> case [114:12]
+    |       |   |   |   |--EXPR -> EXPR [114:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [114:17]
+    |       |   |   |   `--COLON -> : [114:18]
+    |       |   |   |--LITERAL_CASE -> case [115:12]
+    |       |   |   |   |--EXPR -> EXPR [115:17]
+    |       |   |   |   |   `--NUM_INT -> 2 [115:17]
+    |       |   |   |   `--COLON -> : [115:18]
+    |       |   |   `--SLIST -> SLIST [116:17]
+    |       |   |       |--EXPR -> EXPR [116:17]
+    |       |   |       |   `--POST_DEC -> -- [116:17]
+    |       |   |       |       `--IDENT -> i [116:16]
+    |       |   |       `--SEMI -> ; [116:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [118:12]
+    |       |   |   |--LITERAL_CASE -> case [118:12]
+    |       |   |   |   |--EXPR -> EXPR [118:17]
+    |       |   |   |   |   `--NUM_INT -> 3 [118:17]
+    |       |   |   |   `--COLON -> : [118:18]
+    |       |   |   `--SLIST -> SLIST [118:20]
+    |       |   |       `--SLIST -> { [118:20]
+    |       |   |           `--RCURLY -> } [118:22]
+    |       |   `--RCURLY -> } [122:8]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [124:8]
+    |       |   |--MODIFIERS -> MODIFIERS [124:8]
+    |       |   |--TYPE -> TYPE [124:8]
+    |       |   |   `--IDENT -> String [124:8]
+    |       |   |--IDENT -> breaks [124:15]
+    |       |   `--ASSIGN -> = [124:22]
+    |       |       `--EXPR -> EXPR [128:12]
+    |       |           `--PLUS -> + [128:12]
+    |       |               |--PLUS -> + [126:12]
+    |       |               |   |--STRING_LITERAL -> "" [124:24]
+    |       |               |   `--STRING_LITERAL -> "</table>" [126:14]
+    |       |               `--STRING_LITERAL -> "" [128:14]
+    |       |--SEMI -> ; [130:8]
+    |       `--RCURLY -> } [131:4]
+    |--METHOD_DEF -> METHOD_DEF [133:4]
+    |   |--MODIFIERS -> MODIFIERS [133:4]
+    |   |   `--LITERAL_PUBLIC -> public [133:4]
+    |   |--TYPE -> TYPE [133:11]
+    |   |   `--LITERAL_VOID -> void [133:11]
+    |   |--IDENT -> foo2 [133:16]
+    |   |--LPAREN -> ( [133:20]
+    |   |--PARAMETERS -> PARAMETERS [133:21]
+    |   |--RPAREN -> ) [133:21]
+    |   `--SLIST -> { [133:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [134:8]
+    |       |   |--MODIFIERS -> MODIFIERS [134:8]
+    |       |   |--TYPE -> TYPE [134:8]
+    |       |   |   `--LITERAL_INT -> int [134:8]
+    |       |   |--IDENT -> a [134:12]
+    |       |   `--ASSIGN -> = [134:14]
+    |       |       `--EXPR -> EXPR [134:16]
+    |       |           `--NUM_INT -> 1 [134:16]
+    |       |--SEMI -> ; [134:17]
+    |       |--LITERAL_SWITCH -> switch [135:8]
+    |       |   |--LPAREN -> ( [135:15]
+    |       |   |--EXPR -> EXPR [135:16]
+    |       |   |   `--IDENT -> a [135:16]
+    |       |   |--RPAREN -> ) [135:17]
+    |       |   |--LCURLY -> { [135:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [136:12]
+    |       |   |   |--LITERAL_CASE -> case [136:12]
+    |       |   |   |   |--EXPR -> EXPR [136:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [136:17]
+    |       |   |   |   `--COLON -> : [136:18]
+    |       |   |   `--LITERAL_DEFAULT -> default [137:12]
+    |       |   |       `--COLON -> : [137:19]
+    |       |   `--RCURLY -> } [139:8]
+    |       `--RCURLY -> } [140:4]
+    |--METHOD_DEF -> METHOD_DEF [142:4]
+    |   |--MODIFIERS -> MODIFIERS [142:4]
+    |   |   `--LITERAL_PUBLIC -> public [142:4]
+    |   |--TYPE -> TYPE [142:11]
+    |   |   `--LITERAL_VOID -> void [142:11]
+    |   |--IDENT -> foo3 [142:16]
+    |   |--LPAREN -> ( [142:20]
+    |   |--PARAMETERS -> PARAMETERS [142:21]
+    |   |--RPAREN -> ) [142:21]
+    |   `--SLIST -> { [142:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [143:8]
+    |       |   |--MODIFIERS -> MODIFIERS [143:8]
+    |       |   |--TYPE -> TYPE [143:8]
+    |       |   |   `--LITERAL_INT -> int [143:8]
+    |       |   |--IDENT -> a [143:12]
+    |       |   `--ASSIGN -> = [143:14]
+    |       |       `--EXPR -> EXPR [143:16]
+    |       |           `--NUM_INT -> 1 [143:16]
+    |       |--SEMI -> ; [143:17]
+    |       |--LITERAL_SWITCH -> switch [144:8]
+    |       |   |--LPAREN -> ( [144:15]
+    |       |   |--EXPR -> EXPR [144:16]
+    |       |   |   `--IDENT -> a [144:16]
+    |       |   |--RPAREN -> ) [144:17]
+    |       |   |--LCURLY -> { [144:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [145:12]
+    |       |   |   |--LITERAL_CASE -> case [145:12]
+    |       |   |   |   |--EXPR -> EXPR [145:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [145:17]
+    |       |   |   |   `--COLON -> : [145:18]
+    |       |   |   `--LITERAL_DEFAULT -> default [146:12]
+    |       |   |       `--COLON -> : [146:19]
+    |       |   `--RCURLY -> } [149:8]
+    |       `--RCURLY -> } [150:4]
+    |--METHOD_DEF -> METHOD_DEF [152:4]
+    |   |--MODIFIERS -> MODIFIERS [152:4]
+    |   |   `--LITERAL_PUBLIC -> public [152:4]
+    |   |--TYPE -> TYPE [152:11]
+    |   |   `--LITERAL_VOID -> void [152:11]
+    |   |--IDENT -> foo4 [152:16]
+    |   |--LPAREN -> ( [152:20]
+    |   |--PARAMETERS -> PARAMETERS [152:21]
+    |   |--RPAREN -> ) [152:21]
+    |   `--SLIST -> { [152:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [153:8]
+    |       |   |--MODIFIERS -> MODIFIERS [153:8]
+    |       |   |--TYPE -> TYPE [153:8]
+    |       |   |   `--LITERAL_INT -> int [153:8]
+    |       |   |--IDENT -> a [153:12]
+    |       |   `--ASSIGN -> = [153:14]
+    |       |       `--EXPR -> EXPR [153:16]
+    |       |           `--NUM_INT -> 1 [153:16]
+    |       |--SEMI -> ; [153:17]
+    |       |--LITERAL_SWITCH -> switch [154:8]
+    |       |   |--LPAREN -> ( [154:15]
+    |       |   |--EXPR -> EXPR [154:16]
+    |       |   |   `--IDENT -> a [154:16]
+    |       |   |--RPAREN -> ) [154:17]
+    |       |   |--LCURLY -> { [154:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [155:12]
+    |       |   |   |--LITERAL_CASE -> case [155:12]
+    |       |   |   |   |--EXPR -> EXPR [155:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [155:17]
+    |       |   |   |   `--COLON -> : [155:18]
+    |       |   |   `--SLIST -> SLIST [156:16]
+    |       |   |       |--VARIABLE_DEF -> VARIABLE_DEF [156:16]
+    |       |   |       |   |--MODIFIERS -> MODIFIERS [156:16]
+    |       |   |       |   |--TYPE -> TYPE [156:16]
+    |       |   |       |   |   `--LITERAL_INT -> int [156:16]
+    |       |   |       |   `--IDENT -> b [156:20]
+    |       |   |       `--SEMI -> ; [156:21]
+    |       |   |--CASE_GROUP -> CASE_GROUP [158:12]
+    |       |   |   `--LITERAL_DEFAULT -> default [158:12]
+    |       |   |       `--COLON -> : [158:19]
+    |       |   `--RCURLY -> } [159:8]
+    |       `--RCURLY -> } [160:4]
+    |--METHOD_DEF -> METHOD_DEF [162:4]
+    |   |--MODIFIERS -> MODIFIERS [162:4]
+    |   |   `--LITERAL_PUBLIC -> public [162:4]
+    |   |--TYPE -> TYPE [162:11]
+    |   |   `--LITERAL_VOID -> void [162:11]
+    |   |--IDENT -> foo5 [162:16]
+    |   |--LPAREN -> ( [162:20]
+    |   |--PARAMETERS -> PARAMETERS [162:21]
+    |   |--RPAREN -> ) [162:21]
+    |   `--SLIST -> { [162:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [163:8]
+    |       |   |--MODIFIERS -> MODIFIERS [163:8]
+    |       |   |--TYPE -> TYPE [163:8]
+    |       |   |   `--LITERAL_INT -> int [163:8]
+    |       |   |--IDENT -> a [163:12]
+    |       |   `--ASSIGN -> = [163:14]
+    |       |       `--EXPR -> EXPR [163:16]
+    |       |           `--NUM_INT -> 1 [163:16]
+    |       |--SEMI -> ; [163:17]
+    |       |--LITERAL_SWITCH -> switch [164:8]
+    |       |   |--LPAREN -> ( [164:15]
+    |       |   |--EXPR -> EXPR [164:16]
+    |       |   |   `--IDENT -> a [164:16]
+    |       |   |--RPAREN -> ) [164:17]
+    |       |   |--LCURLY -> { [164:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [165:12]
+    |       |   |   |--LITERAL_CASE -> case [165:12]
+    |       |   |   |   |--EXPR -> EXPR [165:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [165:17]
+    |       |   |   |   `--COLON -> : [165:18]
+    |       |   |   `--SLIST -> SLIST [166:16]
+    |       |   |       |--VARIABLE_DEF -> VARIABLE_DEF [166:16]
+    |       |   |       |   |--MODIFIERS -> MODIFIERS [166:16]
+    |       |   |       |   |--TYPE -> TYPE [166:16]
+    |       |   |       |   |   `--LITERAL_INT -> int [166:16]
+    |       |   |       |   `--IDENT -> b [166:20]
+    |       |   |       `--SEMI -> ; [166:21]
+    |       |   |--CASE_GROUP -> CASE_GROUP [168:12]
+    |       |   |   `--LITERAL_DEFAULT -> default [168:12]
+    |       |   |       `--COLON -> : [168:19]
+    |       |   `--RCURLY -> } [169:8]
+    |       `--RCURLY -> } [170:4]
+    |--METHOD_DEF -> METHOD_DEF [172:4]
+    |   |--MODIFIERS -> MODIFIERS [172:4]
+    |   |   `--LITERAL_PUBLIC -> public [172:4]
+    |   |--TYPE -> TYPE [172:11]
+    |   |   `--LITERAL_VOID -> void [172:11]
+    |   |--IDENT -> foo6 [172:16]
+    |   |--LPAREN -> ( [172:20]
+    |   |--PARAMETERS -> PARAMETERS [172:21]
+    |   |--RPAREN -> ) [172:21]
+    |   `--SLIST -> { [172:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [173:8]
+    |       |   |--MODIFIERS -> MODIFIERS [173:8]
+    |       |   |--TYPE -> TYPE [173:8]
+    |       |   |   `--LITERAL_INT -> int [173:8]
+    |       |   |--IDENT -> a [173:12]
+    |       |   `--ASSIGN -> = [173:14]
+    |       |       `--EXPR -> EXPR [173:16]
+    |       |           `--NUM_INT -> 1 [173:16]
+    |       |--SEMI -> ; [173:17]
+    |       |--LITERAL_SWITCH -> switch [174:8]
+    |       |   |--LPAREN -> ( [174:15]
+    |       |   |--EXPR -> EXPR [174:16]
+    |       |   |   `--IDENT -> a [174:16]
+    |       |   |--RPAREN -> ) [174:17]
+    |       |   |--LCURLY -> { [174:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [175:12]
+    |       |   |   |--LITERAL_CASE -> case [175:12]
+    |       |   |   |   |--EXPR -> EXPR [175:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [175:17]
+    |       |   |   |   `--COLON -> : [175:18]
+    |       |   |   `--SLIST -> SLIST [176:16]
+    |       |   |       |--VARIABLE_DEF -> VARIABLE_DEF [176:16]
+    |       |   |       |   |--MODIFIERS -> MODIFIERS [176:16]
+    |       |   |       |   |--TYPE -> TYPE [176:16]
+    |       |   |       |   |   `--LITERAL_INT -> int [176:16]
+    |       |   |       |   `--IDENT -> b [176:20]
+    |       |   |       `--SEMI -> ; [176:21]
+    |       |   |--CASE_GROUP -> CASE_GROUP [178:12]
+    |       |   |   `--LITERAL_DEFAULT -> default [178:12]
+    |       |   |       `--COLON -> : [178:19]
+    |       |   `--RCURLY -> } [179:8]
+    |       `--RCURLY -> } [180:4]
+    |--METHOD_DEF -> METHOD_DEF [182:4]
+    |   |--MODIFIERS -> MODIFIERS [182:4]
+    |   |   `--LITERAL_PUBLIC -> public [182:4]
+    |   |--TYPE -> TYPE [182:11]
+    |   |   `--LITERAL_VOID -> void [182:11]
+    |   |--IDENT -> foo7 [182:16]
+    |   |--LPAREN -> ( [182:20]
+    |   |--PARAMETERS -> PARAMETERS [182:21]
+    |   |--RPAREN -> ) [182:21]
+    |   `--SLIST -> { [182:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [183:8]
+    |       |   |--MODIFIERS -> MODIFIERS [183:8]
+    |       |   |--TYPE -> TYPE [183:8]
+    |       |   |   `--LITERAL_INT -> int [183:8]
+    |       |   |--IDENT -> a [183:12]
+    |       |   `--ASSIGN -> = [183:14]
+    |       |       `--EXPR -> EXPR [183:16]
+    |       |           `--NUM_INT -> 2 [183:16]
+    |       |--SEMI -> ; [183:17]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [184:8]
+    |       |   |--MODIFIERS -> MODIFIERS [184:8]
+    |       |   |--TYPE -> TYPE [184:8]
+    |       |   |   `--IDENT -> String [184:8]
+    |       |   |--IDENT -> s [184:15]
+    |       |   `--ASSIGN -> = [184:17]
+    |       |       `--EXPR -> EXPR [184:19]
+    |       |           `--STRING_LITERAL -> "" [184:19]
+    |       |--SEMI -> ; [184:21]
+    |       |--LITERAL_SWITCH -> switch [185:8]
+    |       |   |--LPAREN -> ( [185:15]
+    |       |   |--EXPR -> EXPR [185:16]
+    |       |   |   `--IDENT -> a [185:16]
+    |       |   |--RPAREN -> ) [185:17]
+    |       |   |--LCURLY -> { [185:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [189:12]
+    |       |   |   |--LITERAL_CASE -> case [189:12]
+    |       |   |   |   |--EXPR -> EXPR [189:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [189:17]
+    |       |   |   |   `--COLON -> : [189:18]
+    |       |   |   |--LITERAL_CASE -> case [190:12]
+    |       |   |   |   |--EXPR -> EXPR [190:17]
+    |       |   |   |   |   `--NUM_INT -> 2 [190:17]
+    |       |   |   |   `--COLON -> : [190:18]
+    |       |   |   `--SLIST -> SLIST [193:20]
+    |       |   |       |--EXPR -> EXPR [193:20]
+    |       |   |       |   `--METHOD_CALL -> ( [193:20]
+    |       |   |       |       |--IDENT -> foo1 [193:16]
+    |       |   |       |       |--ELIST -> ELIST [193:21]
+    |       |   |       |       `--RPAREN -> ) [193:21]
+    |       |   |       `--SEMI -> ; [193:22]
+    |       |   |--CASE_GROUP -> CASE_GROUP [195:12]
+    |       |   |   |--LITERAL_CASE -> case [195:12]
+    |       |   |   |   |--EXPR -> EXPR [195:17]
+    |       |   |   |   |   `--NUM_INT -> 3 [195:17]
+    |       |   |   |   `--COLON -> : [195:18]
+    |       |   |   |--LITERAL_CASE -> case [199:12]
+    |       |   |   |   |--EXPR -> EXPR [199:17]
+    |       |   |   |   |   `--NUM_INT -> 4 [199:17]
+    |       |   |   |   `--COLON -> : [199:18]
+    |       |   |   |--LITERAL_CASE -> case [201:12]
+    |       |   |   |   |--EXPR -> EXPR [201:17]
+    |       |   |   |   |   `--NUM_INT -> 5 [201:17]
+    |       |   |   |   `--COLON -> : [201:18]
+    |       |   |   `--SLIST -> SLIST [202:48]
+    |       |   |       |--EXPR -> EXPR [202:48]
+    |       |   |       |   `--METHOD_CALL -> ( [202:48]
+    |       |   |       |       |--DOT -> . [202:39]
+    |       |   |       |       |   |--METHOD_CALL -> ( [202:37]
+    |       |   |       |       |   |   |--DOT -> . [202:28]
+    |       |   |       |       |   |   |   |--METHOD_CALL -> ( [202:26]
+    |       |   |       |       |   |   |   |   |--DOT -> . [202:17]
+    |       |   |       |       |   |   |   |   |   |--IDENT -> s [202:16]
+    |       |   |       |       |   |   |   |   |   `--IDENT -> toString [202:18]
+    |       |   |       |       |   |   |   |   |--ELIST -> ELIST [202:27]
+    |       |   |       |       |   |   |   |   `--RPAREN -> ) [202:27]
+    |       |   |       |       |   |   |   `--IDENT -> toString [202:29]
+    |       |   |       |       |   |   |--ELIST -> ELIST [202:38]
+    |       |   |       |       |   |   `--RPAREN -> ) [202:38]
+    |       |   |       |       |   `--IDENT -> toString [202:40]
+    |       |   |       |       |--ELIST -> ELIST [202:49]
+    |       |   |       |       `--RPAREN -> ) [202:49]
+    |       |   |       `--SEMI -> ; [202:50]
+    |       |   |--CASE_GROUP -> CASE_GROUP [206:12]
+    |       |   |   `--LITERAL_DEFAULT -> default [206:12]
+    |       |   |       `--COLON -> : [206:19]
+    |       |   `--RCURLY -> } [207:8]
+    |       `--RCURLY -> } [208:4]
+    |--METHOD_DEF -> METHOD_DEF [210:4]
+    |   |--MODIFIERS -> MODIFIERS [210:4]
+    |   |   `--LITERAL_PUBLIC -> public [210:4]
+    |   |--TYPE -> TYPE [210:11]
+    |   |   `--LITERAL_VOID -> void [210:11]
+    |   |--IDENT -> foo8 [210:16]
+    |   |--LPAREN -> ( [210:20]
+    |   |--PARAMETERS -> PARAMETERS [210:21]
+    |   |--RPAREN -> ) [210:21]
+    |   `--SLIST -> { [210:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [211:8]
+    |       |   |--MODIFIERS -> MODIFIERS [211:8]
+    |       |   |--TYPE -> TYPE [211:8]
+    |       |   |   `--LITERAL_INT -> int [211:8]
+    |       |   |--IDENT -> a [211:12]
+    |       |   `--ASSIGN -> = [211:14]
+    |       |       `--EXPR -> EXPR [211:16]
+    |       |           `--NUM_INT -> 2 [211:16]
+    |       |--SEMI -> ; [211:17]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [212:8]
+    |       |   |--MODIFIERS -> MODIFIERS [212:8]
+    |       |   |--TYPE -> TYPE [212:8]
+    |       |   |   `--IDENT -> String [212:8]
+    |       |   |--IDENT -> s [212:15]
+    |       |   `--ASSIGN -> = [212:17]
+    |       |       `--EXPR -> EXPR [212:19]
+    |       |           `--STRING_LITERAL -> "" [212:19]
+    |       |--SEMI -> ; [212:21]
+    |       |--LITERAL_SWITCH -> switch [213:8]
+    |       |   |--LPAREN -> ( [213:15]
+    |       |   |--EXPR -> EXPR [213:16]
+    |       |   |   `--IDENT -> a [213:16]
+    |       |   |--RPAREN -> ) [213:17]
+    |       |   |--LCURLY -> { [213:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [217:12]
+    |       |   |   |--LITERAL_CASE -> case [217:12]
+    |       |   |   |   |--EXPR -> EXPR [217:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [217:17]
+    |       |   |   |   `--COLON -> : [217:18]
+    |       |   |   |--LITERAL_CASE -> case [218:12]
+    |       |   |   |   |--EXPR -> EXPR [218:17]
+    |       |   |   |   |   `--NUM_INT -> 2 [218:17]
+    |       |   |   |   `--COLON -> : [218:18]
+    |       |   |   `--SLIST -> SLIST [221:20]
+    |       |   |       |--EXPR -> EXPR [221:20]
+    |       |   |       |   `--METHOD_CALL -> ( [221:20]
+    |       |   |       |       |--IDENT -> foo1 [221:16]
+    |       |   |       |       |--ELIST -> ELIST [221:21]
+    |       |   |       |       `--RPAREN -> ) [221:21]
+    |       |   |       `--SEMI -> ; [221:22]
+    |       |   |--CASE_GROUP -> CASE_GROUP [223:12]
+    |       |   |   |--LITERAL_CASE -> case [223:12]
+    |       |   |   |   |--EXPR -> EXPR [223:17]
+    |       |   |   |   |   `--NUM_INT -> 3 [223:17]
+    |       |   |   |   `--COLON -> : [223:18]
+    |       |   |   `--SLIST -> SLIST [226:48]
+    |       |   |       |--EXPR -> EXPR [226:48]
+    |       |   |       |   `--METHOD_CALL -> ( [226:48]
+    |       |   |       |       |--DOT -> . [226:39]
+    |       |   |       |       |   |--METHOD_CALL -> ( [226:37]
+    |       |   |       |       |   |   |--DOT -> . [226:28]
+    |       |   |       |       |   |   |   |--METHOD_CALL -> ( [226:26]
+    |       |   |       |       |   |   |   |   |--DOT -> . [226:17]
+    |       |   |       |       |   |   |   |   |   |--IDENT -> s [226:16]
+    |       |   |       |       |   |   |   |   |   `--IDENT -> toString [226:18]
+    |       |   |       |       |   |   |   |   |--ELIST -> ELIST [226:27]
+    |       |   |       |       |   |   |   |   `--RPAREN -> ) [226:27]
+    |       |   |       |       |   |   |   `--IDENT -> toString [226:29]
+    |       |   |       |       |   |   |--ELIST -> ELIST [226:38]
+    |       |   |       |       |   |   `--RPAREN -> ) [226:38]
+    |       |   |       |       |   `--IDENT -> toString [226:40]
+    |       |   |       |       |--ELIST -> ELIST [226:49]
+    |       |   |       |       `--RPAREN -> ) [226:49]
+    |       |   |       `--SEMI -> ; [226:50]
+    |       |   |--CASE_GROUP -> CASE_GROUP [228:12]
+    |       |   |   |--LITERAL_CASE -> case [228:12]
+    |       |   |   |   |--EXPR -> EXPR [228:17]
+    |       |   |   |   |   `--NUM_INT -> 4 [228:17]
+    |       |   |   |   `--COLON -> : [228:18]
+    |       |   |   `--LITERAL_DEFAULT -> default [230:12]
+    |       |   |       `--COLON -> : [230:19]
+    |       |   `--RCURLY -> } [231:8]
+    |       `--RCURLY -> } [232:4]
+    |--METHOD_DEF -> METHOD_DEF [234:4]
+    |   |--MODIFIERS -> MODIFIERS [234:4]
+    |   |   `--LITERAL_PUBLIC -> public [234:4]
+    |   |--TYPE -> TYPE [234:11]
+    |   |   `--LITERAL_VOID -> void [234:11]
+    |   |--IDENT -> foo9 [234:16]
+    |   |--LPAREN -> ( [234:20]
+    |   |--PARAMETERS -> PARAMETERS [234:21]
+    |   |--RPAREN -> ) [234:21]
+    |   `--SLIST -> { [234:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [235:8]
+    |       |   |--MODIFIERS -> MODIFIERS [235:8]
+    |       |   |--TYPE -> TYPE [235:8]
+    |       |   |   `--LITERAL_INT -> int [235:8]
+    |       |   |--IDENT -> a [235:12]
+    |       |   `--ASSIGN -> = [235:14]
+    |       |       `--EXPR -> EXPR [235:16]
+    |       |           `--NUM_INT -> 5 [235:16]
+    |       |--SEMI -> ; [235:17]
+    |       |--LITERAL_SWITCH -> switch [236:8]
+    |       |   |--LPAREN -> ( [236:15]
+    |       |   |--EXPR -> EXPR [236:16]
+    |       |   |   `--IDENT -> a [236:16]
+    |       |   |--RPAREN -> ) [236:17]
+    |       |   |--LCURLY -> { [236:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [237:12]
+    |       |   |   |--LITERAL_CASE -> case [237:12]
+    |       |   |   |   |--EXPR -> EXPR [237:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [237:17]
+    |       |   |   |   `--COLON -> : [237:18]
+    |       |   |   `--LITERAL_CASE -> case [238:12]
+    |       |   |       |--EXPR -> EXPR [238:17]
+    |       |   |       |   `--NUM_INT -> 2 [238:17]
+    |       |   |       `--COLON -> : [238:18]
+    |       |   `--RCURLY -> } [240:8]
+    |       `--RCURLY -> } [241:4]
+    |--METHOD_DEF -> METHOD_DEF [243:4]
+    |   |--MODIFIERS -> MODIFIERS [243:4]
+    |   |   `--LITERAL_PUBLIC -> public [243:4]
+    |   |--TYPE -> TYPE [243:11]
+    |   |   `--LITERAL_VOID -> void [243:11]
+    |   |--IDENT -> foo10 [243:16]
+    |   |--LPAREN -> ( [243:21]
+    |   |--PARAMETERS -> PARAMETERS [243:22]
+    |   |--RPAREN -> ) [243:22]
+    |   `--SLIST -> { [243:24]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [244:8]
+    |       |   |--MODIFIERS -> MODIFIERS [244:8]
+    |       |   |--TYPE -> TYPE [244:8]
+    |       |   |   `--LITERAL_INT -> int [244:8]
+    |       |   |--IDENT -> a [244:12]
+    |       |   `--ASSIGN -> = [244:14]
+    |       |       `--EXPR -> EXPR [244:16]
+    |       |           `--NUM_INT -> 5 [244:16]
+    |       |--SEMI -> ; [244:17]
+    |       |--LITERAL_SWITCH -> switch [245:8]
+    |       |   |--LPAREN -> ( [245:15]
+    |       |   |--EXPR -> EXPR [245:16]
+    |       |   |   `--IDENT -> a [245:16]
+    |       |   |--RPAREN -> ) [245:17]
+    |       |   |--LCURLY -> { [245:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [246:12]
+    |       |   |   |--LITERAL_CASE -> case [246:12]
+    |       |   |   |   |--EXPR -> EXPR [246:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [246:17]
+    |       |   |   |   `--COLON -> : [246:18]
+    |       |   |   `--LITERAL_DEFAULT -> default [247:12]
+    |       |   |       `--COLON -> : [247:19]
+    |       |   `--RCURLY -> } [249:8]
+    |       `--RCURLY -> } [250:4]
+    |--METHOD_DEF -> METHOD_DEF [252:4]
+    |   |--MODIFIERS -> MODIFIERS [252:4]
+    |   |   `--LITERAL_PUBLIC -> public [252:4]
+    |   |--TYPE -> TYPE [252:11]
+    |   |   `--LITERAL_VOID -> void [252:11]
+    |   |--IDENT -> foo11 [252:16]
+    |   |--LPAREN -> ( [252:21]
+    |   |--PARAMETERS -> PARAMETERS [252:22]
+    |   |--RPAREN -> ) [252:22]
+    |   `--SLIST -> { [252:24]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [253:8]
+    |       |   |--MODIFIERS -> MODIFIERS [253:8]
+    |       |   |--TYPE -> TYPE [253:8]
+    |       |   |   `--LITERAL_INT -> int [253:8]
+    |       |   |--IDENT -> a [253:12]
+    |       |   `--ASSIGN -> = [253:14]
+    |       |       `--EXPR -> EXPR [253:16]
+    |       |           `--NUM_INT -> 5 [253:16]
+    |       |--SEMI -> ; [253:17]
+    |       |--LITERAL_SWITCH -> switch [254:8]
+    |       |   |--LPAREN -> ( [254:15]
+    |       |   |--EXPR -> EXPR [254:16]
+    |       |   |   `--IDENT -> a [254:16]
+    |       |   |--RPAREN -> ) [254:17]
+    |       |   |--LCURLY -> { [254:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [255:12]
+    |       |   |   |--LITERAL_CASE -> case [255:12]
+    |       |   |   |   |--EXPR -> EXPR [255:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [255:17]
+    |       |   |   |   `--COLON -> : [255:18]
+    |       |   |   `--LITERAL_CASE -> case [256:12]
+    |       |   |       |--EXPR -> EXPR [256:17]
+    |       |   |       |   `--NUM_INT -> 2 [256:17]
+    |       |   |       `--COLON -> : [256:18]
+    |       |   `--RCURLY -> } [258:8]
+    |       `--RCURLY -> } [259:4]
+    |--METHOD_DEF -> METHOD_DEF [261:4]
+    |   |--MODIFIERS -> MODIFIERS [261:4]
+    |   |   `--LITERAL_PUBLIC -> public [261:4]
+    |   |--TYPE -> TYPE [261:11]
+    |   |   `--LITERAL_VOID -> void [261:11]
+    |   |--IDENT -> foo12 [261:16]
+    |   |--LPAREN -> ( [261:21]
+    |   |--PARAMETERS -> PARAMETERS [261:22]
+    |   |--RPAREN -> ) [261:22]
+    |   `--SLIST -> { [261:24]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [262:8]
+    |       |   |--MODIFIERS -> MODIFIERS [262:8]
+    |       |   |--TYPE -> TYPE [262:8]
+    |       |   |   `--LITERAL_INT -> int [262:8]
+    |       |   |--IDENT -> a [262:12]
+    |       |   `--ASSIGN -> = [262:14]
+    |       |       `--EXPR -> EXPR [262:16]
+    |       |           `--NUM_INT -> 5 [262:16]
+    |       |--SEMI -> ; [262:17]
+    |       |--LITERAL_SWITCH -> switch [263:8]
+    |       |   |--LPAREN -> ( [263:15]
+    |       |   |--EXPR -> EXPR [263:16]
+    |       |   |   `--IDENT -> a [263:16]
+    |       |   |--RPAREN -> ) [263:17]
+    |       |   |--LCURLY -> { [263:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [265:12]
+    |       |   |   `--LITERAL_CASE -> case [265:12]
+    |       |   |       |--EXPR -> EXPR [265:17]
+    |       |   |       |   `--NUM_INT -> 1 [265:17]
+    |       |   |       `--COLON -> : [265:18]
+    |       |   `--RCURLY -> } [266:8]
+    |       `--RCURLY -> } [267:4]
+    `--RCURLY -> } [268:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickySwitchWithComments.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickySwitchWithComments.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickySwitchWithComments.java
@@ -0,0 +1,276 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+public class InputAntlr4AstRegressionTrickySwitchWithComments {
+
+    /**
+     * Javadoc here.
+     */
+    private static void fooSwitch() {
+        switch("") {
+            case "0": //some comment
+            case "1":
+                // my comment
+                foo1();
+                break;
+            case "2":
+                // my comment
+                //comment
+                foo1();
+                // comment
+                break;
+            case "3":
+            /* // warn */
+                foo1();
+                /* com */
+                break;
+            case "5":
+                foo1();
+                   // warn
+            case "6":
+                int k = 7;
+                // fall through
+            case "7":
+                if (true) {}
+                   // warn
+            case "8":
+                break;
+            case "9":
+                foo1();
+                // fall through
+            case "10": {
+                if (true) {}
+                // fall through
+            }
+            case "11": {
+            // fall through
+            }
+            case "28": {
+                // fall through
+            }
+            case "12": {
+      // warn
+                int i;
+            }
+            case "13": {
+                       // some comment in empty case block
+            }
+            case "14": {
+        // warn
+            }
+            case "15": {
+                foo1();
+                      // warn
+            }
+            case "16": {
+                int a;
+            }
+            // fall through
+            case "17": {
+                int a;
+            }
+              // warn
+                case "18": { System.lineSeparator();
+                }   // trailing comment
+            case "19":
+                // comment
+            case "20":
+            // comment
+            case "21":
+            default:
+                // comment
+                break;
+        }
+    }
+
+    private static void foo1() {
+        if (true) {
+            switch(1) {
+                case 0:
+
+                case 1:
+                        // warn
+                    int b = 10;
+                default:
+                 // comment
+            }
+
+        }
+    }
+    /** Single line javadoc here */
+    public void fooDotInCaseBlock() {
+        int i = 0;
+        String s = "";
+
+        switch (i) {
+            case -2:
+                // what
+                i++;
+                // no break here
+            case 0:
+                // what
+                s.indexOf("ignore");
+                // no break here
+            case -1:
+                 // what
+                 s.indexOf("no way");
+               // warn
+            case 1:
+            case 2:
+                i--;
+                // no break here
+            case 3: { }
+            // fall through
+
+
+        }
+
+        String breaks = ""
+        // warn
+            + "</table>"
+            // middle
+            + ""
+        // end
+        ;
+    }
+
+    /**
+     * Javadoc here.
+     *
+     */
+    public void foo2() {
+        int a = 1;
+        switch (a) {
+            case 1/*block comment
+            */:
+            default:
+    // warn
+        }
+    }
+
+    public void foo3() {
+        int a =/*Block comment here */ 1;
+        switch (a) {
+            case 1:
+            default:
+
+                // comment
+        }
+    }
+
+    public void foo4() {
+        int a = 1;
+        switch (a) {
+            case 1:
+                int b;
+                  // warn
+            default:
+        }
+    }
+
+    public void foo5() {
+        int a = 1;
+        switch (a) {
+            case 1:
+                int b;
+            // comment
+            default:
+        }
+    }
+
+    public void foo6() {
+        int a = 1;
+        switch (a) {
+            case 1:
+                int b;
+                // comment
+            default:
+        }
+    }
+
+    public void foo7() {
+        int a = 2;
+        String s = "";
+        switch (a) {
+            // comment
+            // comment
+            // comment
+            case 1:
+            case 2:
+                // comment
+                // comment
+                foo1();
+                // comment
+            case 3:
+                // comment
+                // comment
+                // comment
+            case 4:
+    // warn
+            case 5:
+                s.toString().toString().toString();
+                      // warn
+                    // warn
+                 // warn
+            default:
+        }
+    }
+
+    public void foo8() {
+        int a = 2;
+        String s = "";
+        switch (a) {
+            // comment
+            // comment
+            // comment
+            case 1:
+            case 2:
+                // comment
+                // comment
+                foo1();
+                // comment
+            case 3:
+                // comment
+                // comment
+                s.toString().toString().toString();
+                // comment
+            case 4:
+      // warn
+            default:
+        }
+    }
+
+    public void foo9() {
+        int a = 5;
+        switch (a) {
+            case 1:
+            case 2:
+                // comment
+        }
+    }
+
+    public void foo10() {
+        int a = 5;
+        switch (a) {
+            case 1:
+            default:
+                // comment
+        }
+    }
+
+    public void foo11() {
+        int a = 5;
+        switch (a) {
+            case 1:
+            case 2:
+                // comment
+        }
+    }
+
+    public void foo12() {
+        int a = 5;
+        switch (a) {
+            // comment
+            case 1:
+        }
+    }
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickySwitchWithComments.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickySwitchWithComments.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickySwitchWithComments.txt
@@ -0,0 +1,1104 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+CLASS_DEF -> CLASS_DEF [3:0]
+|--MODIFIERS -> MODIFIERS [3:0]
+|   `--LITERAL_PUBLIC -> public [3:0]
+|--LITERAL_CLASS -> class [3:7]
+|--IDENT -> InputAntlr4AstRegressionTrickySwitchWithComments [3:13]
+`--OBJBLOCK -> OBJBLOCK [3:62]
+    |--LCURLY -> { [3:62]
+    |--METHOD_DEF -> METHOD_DEF [8:4]
+    |   |--MODIFIERS -> MODIFIERS [8:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [5:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * Javadoc here.\n      [5:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [7:5]
+    |   |   |--LITERAL_PRIVATE -> private [8:4]
+    |   |   `--LITERAL_STATIC -> static [8:12]
+    |   |--TYPE -> TYPE [8:19]
+    |   |   `--LITERAL_VOID -> void [8:19]
+    |   |--IDENT -> fooSwitch [8:24]
+    |   |--LPAREN -> ( [8:33]
+    |   |--PARAMETERS -> PARAMETERS [8:34]
+    |   |--RPAREN -> ) [8:34]
+    |   `--SLIST -> { [8:36]
+    |       |--LITERAL_SWITCH -> switch [9:8]
+    |       |   |--LPAREN -> ( [9:14]
+    |       |   |--EXPR -> EXPR [9:15]
+    |       |   |   `--STRING_LITERAL -> "" [9:15]
+    |       |   |--RPAREN -> ) [9:17]
+    |       |   |--LCURLY -> { [9:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [10:12]
+    |       |   |   |--LITERAL_CASE -> case [10:12]
+    |       |   |   |   |--EXPR -> EXPR [10:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "0" [10:17]
+    |       |   |   |   `--COLON -> : [10:20]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [10:22]
+    |       |   |   |   `--COMMENT_CONTENT -> some comment\n [10:24]
+    |       |   |   |--LITERAL_CASE -> case [11:12]
+    |       |   |   |   |--EXPR -> EXPR [11:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "1" [11:17]
+    |       |   |   |   `--COLON -> : [11:20]
+    |       |   |   `--SLIST -> SLIST [13:20]
+    |       |   |       |--EXPR -> EXPR [13:20]
+    |       |   |       |   `--METHOD_CALL -> ( [13:20]
+    |       |   |       |       |--SINGLE_LINE_COMMENT -> // [12:16]
+    |       |   |       |       |   `--COMMENT_CONTENT ->  my comment\n [12:18]
+    |       |   |       |       |--IDENT -> foo1 [13:16]
+    |       |   |       |       |--ELIST -> ELIST [13:21]
+    |       |   |       |       `--RPAREN -> ) [13:21]
+    |       |   |       |--SEMI -> ; [13:22]
+    |       |   |       `--LITERAL_BREAK -> break [14:16]
+    |       |   |           `--SEMI -> ; [14:21]
+    |       |   |--CASE_GROUP -> CASE_GROUP [15:12]
+    |       |   |   |--LITERAL_CASE -> case [15:12]
+    |       |   |   |   |--EXPR -> EXPR [15:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "2" [15:17]
+    |       |   |   |   `--COLON -> : [15:20]
+    |       |   |   `--SLIST -> SLIST [18:20]
+    |       |   |       |--EXPR -> EXPR [18:20]
+    |       |   |       |   `--METHOD_CALL -> ( [18:20]
+    |       |   |       |       |--SINGLE_LINE_COMMENT -> // [16:16]
+    |       |   |       |       |   `--COMMENT_CONTENT ->  my comment\n [16:18]
+    |       |   |       |       |--SINGLE_LINE_COMMENT -> // [17:16]
+    |       |   |       |       |   `--COMMENT_CONTENT -> comment\n [17:18]
+    |       |   |       |       |--IDENT -> foo1 [18:16]
+    |       |   |       |       |--ELIST -> ELIST [18:21]
+    |       |   |       |       `--RPAREN -> ) [18:21]
+    |       |   |       |--SEMI -> ; [18:22]
+    |       |   |       |--SINGLE_LINE_COMMENT -> // [19:16]
+    |       |   |       |   `--COMMENT_CONTENT ->  comment\n [19:18]
+    |       |   |       `--LITERAL_BREAK -> break [20:16]
+    |       |   |           `--SEMI -> ; [20:21]
+    |       |   |--CASE_GROUP -> CASE_GROUP [21:12]
+    |       |   |   |--LITERAL_CASE -> case [21:12]
+    |       |   |   |   |--EXPR -> EXPR [21:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "3" [21:17]
+    |       |   |   |   `--COLON -> : [21:20]
+    |       |   |   `--SLIST -> SLIST [23:20]
+    |       |   |       |--EXPR -> EXPR [23:20]
+    |       |   |       |   `--METHOD_CALL -> ( [23:20]
+    |       |   |       |       |--BLOCK_COMMENT_BEGIN -> /* [22:12]
+    |       |   |       |       |   |--COMMENT_CONTENT ->  // warn  [22:14]
+    |       |   |       |       |   `--BLOCK_COMMENT_END -> */ [22:22]
+    |       |   |       |       |--IDENT -> foo1 [23:16]
+    |       |   |       |       |--ELIST -> ELIST [23:21]
+    |       |   |       |       `--RPAREN -> ) [23:21]
+    |       |   |       |--SEMI -> ; [23:22]
+    |       |   |       |--BLOCK_COMMENT_BEGIN -> /* [24:16]
+    |       |   |       |   |--COMMENT_CONTENT ->  com  [24:18]
+    |       |   |       |   `--BLOCK_COMMENT_END -> */ [24:22]
+    |       |   |       `--LITERAL_BREAK -> break [25:16]
+    |       |   |           `--SEMI -> ; [25:21]
+    |       |   |--CASE_GROUP -> CASE_GROUP [26:12]
+    |       |   |   |--LITERAL_CASE -> case [26:12]
+    |       |   |   |   |--EXPR -> EXPR [26:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "5" [26:17]
+    |       |   |   |   `--COLON -> : [26:20]
+    |       |   |   `--SLIST -> SLIST [27:20]
+    |       |   |       |--EXPR -> EXPR [27:20]
+    |       |   |       |   `--METHOD_CALL -> ( [27:20]
+    |       |   |       |       |--IDENT -> foo1 [27:16]
+    |       |   |       |       |--ELIST -> ELIST [27:21]
+    |       |   |       |       `--RPAREN -> ) [27:21]
+    |       |   |       `--SEMI -> ; [27:22]
+    |       |   |--CASE_GROUP -> CASE_GROUP [29:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [28:19]
+    |       |   |   |   `--COMMENT_CONTENT ->  warn\n [28:21]
+    |       |   |   |--LITERAL_CASE -> case [29:12]
+    |       |   |   |   |--EXPR -> EXPR [29:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "6" [29:17]
+    |       |   |   |   `--COLON -> : [29:20]
+    |       |   |   `--SLIST -> SLIST [30:16]
+    |       |   |       |--VARIABLE_DEF -> VARIABLE_DEF [30:16]
+    |       |   |       |   |--MODIFIERS -> MODIFIERS [30:16]
+    |       |   |       |   |--TYPE -> TYPE [30:16]
+    |       |   |       |   |   `--LITERAL_INT -> int [30:16]
+    |       |   |       |   |--IDENT -> k [30:20]
+    |       |   |       |   `--ASSIGN -> = [30:22]
+    |       |   |       |       `--EXPR -> EXPR [30:24]
+    |       |   |       |           `--NUM_INT -> 7 [30:24]
+    |       |   |       `--SEMI -> ; [30:25]
+    |       |   |--CASE_GROUP -> CASE_GROUP [32:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [31:16]
+    |       |   |   |   `--COMMENT_CONTENT ->  fall through\n [31:18]
+    |       |   |   |--LITERAL_CASE -> case [32:12]
+    |       |   |   |   |--EXPR -> EXPR [32:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "7" [32:17]
+    |       |   |   |   `--COLON -> : [32:20]
+    |       |   |   `--SLIST -> SLIST [33:16]
+    |       |   |       `--LITERAL_IF -> if [33:16]
+    |       |   |           |--LPAREN -> ( [33:19]
+    |       |   |           |--EXPR -> EXPR [33:20]
+    |       |   |           |   `--LITERAL_TRUE -> true [33:20]
+    |       |   |           |--RPAREN -> ) [33:24]
+    |       |   |           `--SLIST -> { [33:26]
+    |       |   |               `--RCURLY -> } [33:27]
+    |       |   |--CASE_GROUP -> CASE_GROUP [35:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [34:19]
+    |       |   |   |   `--COMMENT_CONTENT ->  warn\n [34:21]
+    |       |   |   |--LITERAL_CASE -> case [35:12]
+    |       |   |   |   |--EXPR -> EXPR [35:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "8" [35:17]
+    |       |   |   |   `--COLON -> : [35:20]
+    |       |   |   `--SLIST -> SLIST [36:16]
+    |       |   |       `--LITERAL_BREAK -> break [36:16]
+    |       |   |           `--SEMI -> ; [36:21]
+    |       |   |--CASE_GROUP -> CASE_GROUP [37:12]
+    |       |   |   |--LITERAL_CASE -> case [37:12]
+    |       |   |   |   |--EXPR -> EXPR [37:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "9" [37:17]
+    |       |   |   |   `--COLON -> : [37:20]
+    |       |   |   `--SLIST -> SLIST [38:20]
+    |       |   |       |--EXPR -> EXPR [38:20]
+    |       |   |       |   `--METHOD_CALL -> ( [38:20]
+    |       |   |       |       |--IDENT -> foo1 [38:16]
+    |       |   |       |       |--ELIST -> ELIST [38:21]
+    |       |   |       |       `--RPAREN -> ) [38:21]
+    |       |   |       `--SEMI -> ; [38:22]
+    |       |   |--CASE_GROUP -> CASE_GROUP [40:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [39:16]
+    |       |   |   |   `--COMMENT_CONTENT ->  fall through\n [39:18]
+    |       |   |   |--LITERAL_CASE -> case [40:12]
+    |       |   |   |   |--EXPR -> EXPR [40:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "10" [40:17]
+    |       |   |   |   `--COLON -> : [40:21]
+    |       |   |   `--SLIST -> SLIST [40:23]
+    |       |   |       `--SLIST -> { [40:23]
+    |       |   |           |--LITERAL_IF -> if [41:16]
+    |       |   |           |   |--LPAREN -> ( [41:19]
+    |       |   |           |   |--EXPR -> EXPR [41:20]
+    |       |   |           |   |   `--LITERAL_TRUE -> true [41:20]
+    |       |   |           |   |--RPAREN -> ) [41:24]
+    |       |   |           |   `--SLIST -> { [41:26]
+    |       |   |           |       `--RCURLY -> } [41:27]
+    |       |   |           |--SINGLE_LINE_COMMENT -> // [42:16]
+    |       |   |           |   `--COMMENT_CONTENT ->  fall through\n [42:18]
+    |       |   |           `--RCURLY -> } [43:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [44:12]
+    |       |   |   |--LITERAL_CASE -> case [44:12]
+    |       |   |   |   |--EXPR -> EXPR [44:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "11" [44:17]
+    |       |   |   |   `--COLON -> : [44:21]
+    |       |   |   `--SLIST -> SLIST [44:23]
+    |       |   |       `--SLIST -> { [44:23]
+    |       |   |           |--SINGLE_LINE_COMMENT -> // [45:12]
+    |       |   |           |   `--COMMENT_CONTENT ->  fall through\n [45:14]
+    |       |   |           `--RCURLY -> } [46:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [47:12]
+    |       |   |   |--LITERAL_CASE -> case [47:12]
+    |       |   |   |   |--EXPR -> EXPR [47:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "28" [47:17]
+    |       |   |   |   `--COLON -> : [47:21]
+    |       |   |   `--SLIST -> SLIST [47:23]
+    |       |   |       `--SLIST -> { [47:23]
+    |       |   |           |--SINGLE_LINE_COMMENT -> // [48:16]
+    |       |   |           |   `--COMMENT_CONTENT ->  fall through\n [48:18]
+    |       |   |           `--RCURLY -> } [49:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [50:12]
+    |       |   |   |--LITERAL_CASE -> case [50:12]
+    |       |   |   |   |--EXPR -> EXPR [50:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "12" [50:17]
+    |       |   |   |   `--COLON -> : [50:21]
+    |       |   |   `--SLIST -> SLIST [50:23]
+    |       |   |       `--SLIST -> { [50:23]
+    |       |   |           |--VARIABLE_DEF -> VARIABLE_DEF [52:16]
+    |       |   |           |   |--MODIFIERS -> MODIFIERS [52:16]
+    |       |   |           |   |--TYPE -> TYPE [52:16]
+    |       |   |           |   |   |--SINGLE_LINE_COMMENT -> // [51:6]
+    |       |   |           |   |   |   `--COMMENT_CONTENT ->  warn\n [51:8]
+    |       |   |           |   |   `--LITERAL_INT -> int [52:16]
+    |       |   |           |   `--IDENT -> i [52:20]
+    |       |   |           |--SEMI -> ; [52:21]
+    |       |   |           `--RCURLY -> } [53:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [54:12]
+    |       |   |   |--LITERAL_CASE -> case [54:12]
+    |       |   |   |   |--EXPR -> EXPR [54:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "13" [54:17]
+    |       |   |   |   `--COLON -> : [54:21]
+    |       |   |   `--SLIST -> SLIST [54:23]
+    |       |   |       `--SLIST -> { [54:23]
+    |       |   |           |--SINGLE_LINE_COMMENT -> // [55:23]
+    |       |   |           |   `--COMMENT_CONTENT ->  some comment in empty case block\n [55:25]
+    |       |   |           `--RCURLY -> } [56:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [57:12]
+    |       |   |   |--LITERAL_CASE -> case [57:12]
+    |       |   |   |   |--EXPR -> EXPR [57:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "14" [57:17]
+    |       |   |   |   `--COLON -> : [57:21]
+    |       |   |   `--SLIST -> SLIST [57:23]
+    |       |   |       `--SLIST -> { [57:23]
+    |       |   |           |--SINGLE_LINE_COMMENT -> // [58:8]
+    |       |   |           |   `--COMMENT_CONTENT ->  warn\n [58:10]
+    |       |   |           `--RCURLY -> } [59:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [60:12]
+    |       |   |   |--LITERAL_CASE -> case [60:12]
+    |       |   |   |   |--EXPR -> EXPR [60:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "15" [60:17]
+    |       |   |   |   `--COLON -> : [60:21]
+    |       |   |   `--SLIST -> SLIST [60:23]
+    |       |   |       `--SLIST -> { [60:23]
+    |       |   |           |--EXPR -> EXPR [61:20]
+    |       |   |           |   `--METHOD_CALL -> ( [61:20]
+    |       |   |           |       |--IDENT -> foo1 [61:16]
+    |       |   |           |       |--ELIST -> ELIST [61:21]
+    |       |   |           |       `--RPAREN -> ) [61:21]
+    |       |   |           |--SEMI -> ; [61:22]
+    |       |   |           |--SINGLE_LINE_COMMENT -> // [62:22]
+    |       |   |           |   `--COMMENT_CONTENT ->  warn\n [62:24]
+    |       |   |           `--RCURLY -> } [63:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [64:12]
+    |       |   |   |--LITERAL_CASE -> case [64:12]
+    |       |   |   |   |--EXPR -> EXPR [64:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "16" [64:17]
+    |       |   |   |   `--COLON -> : [64:21]
+    |       |   |   `--SLIST -> SLIST [64:23]
+    |       |   |       `--SLIST -> { [64:23]
+    |       |   |           |--VARIABLE_DEF -> VARIABLE_DEF [65:16]
+    |       |   |           |   |--MODIFIERS -> MODIFIERS [65:16]
+    |       |   |           |   |--TYPE -> TYPE [65:16]
+    |       |   |           |   |   `--LITERAL_INT -> int [65:16]
+    |       |   |           |   `--IDENT -> a [65:20]
+    |       |   |           |--SEMI -> ; [65:21]
+    |       |   |           `--RCURLY -> } [66:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [68:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [67:12]
+    |       |   |   |   `--COMMENT_CONTENT ->  fall through\n [67:14]
+    |       |   |   |--LITERAL_CASE -> case [68:12]
+    |       |   |   |   |--EXPR -> EXPR [68:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "17" [68:17]
+    |       |   |   |   `--COLON -> : [68:21]
+    |       |   |   `--SLIST -> SLIST [68:23]
+    |       |   |       `--SLIST -> { [68:23]
+    |       |   |           |--VARIABLE_DEF -> VARIABLE_DEF [69:16]
+    |       |   |           |   |--MODIFIERS -> MODIFIERS [69:16]
+    |       |   |           |   |--TYPE -> TYPE [69:16]
+    |       |   |           |   |   `--LITERAL_INT -> int [69:16]
+    |       |   |           |   `--IDENT -> a [69:20]
+    |       |   |           |--SEMI -> ; [69:21]
+    |       |   |           `--RCURLY -> } [70:12]
+    |       |   |--CASE_GROUP -> CASE_GROUP [72:16]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [71:14]
+    |       |   |   |   `--COMMENT_CONTENT ->  warn\n [71:16]
+    |       |   |   |--LITERAL_CASE -> case [72:16]
+    |       |   |   |   |--EXPR -> EXPR [72:21]
+    |       |   |   |   |   `--STRING_LITERAL -> "18" [72:21]
+    |       |   |   |   `--COLON -> : [72:25]
+    |       |   |   `--SLIST -> SLIST [72:27]
+    |       |   |       `--SLIST -> { [72:27]
+    |       |   |           |--EXPR -> EXPR [72:49]
+    |       |   |           |   `--METHOD_CALL -> ( [72:49]
+    |       |   |           |       |--DOT -> . [72:35]
+    |       |   |           |       |   |--IDENT -> System [72:29]
+    |       |   |           |       |   `--IDENT -> lineSeparator [72:36]
+    |       |   |           |       |--ELIST -> ELIST [72:50]
+    |       |   |           |       `--RPAREN -> ) [72:50]
+    |       |   |           |--SEMI -> ; [72:51]
+    |       |   |           `--RCURLY -> } [73:16]
+    |       |   |--CASE_GROUP -> CASE_GROUP [74:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [73:20]
+    |       |   |   |   `--COMMENT_CONTENT ->  trailing comment\n [73:22]
+    |       |   |   |--LITERAL_CASE -> case [74:12]
+    |       |   |   |   |--EXPR -> EXPR [74:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "19" [74:17]
+    |       |   |   |   `--COLON -> : [74:21]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [75:16]
+    |       |   |   |   `--COMMENT_CONTENT ->  comment\n [75:18]
+    |       |   |   |--LITERAL_CASE -> case [76:12]
+    |       |   |   |   |--EXPR -> EXPR [76:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "20" [76:17]
+    |       |   |   |   `--COLON -> : [76:21]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [77:12]
+    |       |   |   |   `--COMMENT_CONTENT ->  comment\n [77:14]
+    |       |   |   |--LITERAL_CASE -> case [78:12]
+    |       |   |   |   |--EXPR -> EXPR [78:17]
+    |       |   |   |   |   `--STRING_LITERAL -> "21" [78:17]
+    |       |   |   |   `--COLON -> : [78:21]
+    |       |   |   |--LITERAL_DEFAULT -> default [79:12]
+    |       |   |   |   `--COLON -> : [79:19]
+    |       |   |   `--SLIST -> SLIST [81:16]
+    |       |   |       |--SINGLE_LINE_COMMENT -> // [80:16]
+    |       |   |       |   `--COMMENT_CONTENT ->  comment\n [80:18]
+    |       |   |       `--LITERAL_BREAK -> break [81:16]
+    |       |   |           `--SEMI -> ; [81:21]
+    |       |   `--RCURLY -> } [82:8]
+    |       `--RCURLY -> } [83:4]
+    |--METHOD_DEF -> METHOD_DEF [85:4]
+    |   |--MODIFIERS -> MODIFIERS [85:4]
+    |   |   |--LITERAL_PRIVATE -> private [85:4]
+    |   |   `--LITERAL_STATIC -> static [85:12]
+    |   |--TYPE -> TYPE [85:19]
+    |   |   `--LITERAL_VOID -> void [85:19]
+    |   |--IDENT -> foo1 [85:24]
+    |   |--LPAREN -> ( [85:28]
+    |   |--PARAMETERS -> PARAMETERS [85:29]
+    |   |--RPAREN -> ) [85:29]
+    |   `--SLIST -> { [85:31]
+    |       |--LITERAL_IF -> if [86:8]
+    |       |   |--LPAREN -> ( [86:11]
+    |       |   |--EXPR -> EXPR [86:12]
+    |       |   |   `--LITERAL_TRUE -> true [86:12]
+    |       |   |--RPAREN -> ) [86:16]
+    |       |   `--SLIST -> { [86:18]
+    |       |       |--LITERAL_SWITCH -> switch [87:12]
+    |       |       |   |--LPAREN -> ( [87:18]
+    |       |       |   |--EXPR -> EXPR [87:19]
+    |       |       |   |   `--NUM_INT -> 1 [87:19]
+    |       |       |   |--RPAREN -> ) [87:20]
+    |       |       |   |--LCURLY -> { [87:22]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [88:16]
+    |       |       |   |   |--LITERAL_CASE -> case [88:16]
+    |       |       |   |   |   |--EXPR -> EXPR [88:21]
+    |       |       |   |   |   |   `--NUM_INT -> 0 [88:21]
+    |       |       |   |   |   `--COLON -> : [88:22]
+    |       |       |   |   |--LITERAL_CASE -> case [90:16]
+    |       |       |   |   |   |--EXPR -> EXPR [90:21]
+    |       |       |   |   |   |   `--NUM_INT -> 1 [90:21]
+    |       |       |   |   |   `--COLON -> : [90:22]
+    |       |       |   |   `--SLIST -> SLIST [92:20]
+    |       |       |   |       |--VARIABLE_DEF -> VARIABLE_DEF [92:20]
+    |       |       |   |       |   |--MODIFIERS -> MODIFIERS [92:20]
+    |       |       |   |       |   |--TYPE -> TYPE [92:20]
+    |       |       |   |       |   |   |--SINGLE_LINE_COMMENT -> // [91:24]
+    |       |       |   |       |   |   |   `--COMMENT_CONTENT ->  warn\n [91:26]
+    |       |       |   |       |   |   `--LITERAL_INT -> int [92:20]
+    |       |       |   |       |   |--IDENT -> b [92:24]
+    |       |       |   |       |   `--ASSIGN -> = [92:26]
+    |       |       |   |       |       `--EXPR -> EXPR [92:28]
+    |       |       |   |       |           `--NUM_INT -> 10 [92:28]
+    |       |       |   |       `--SEMI -> ; [92:30]
+    |       |       |   |--CASE_GROUP -> CASE_GROUP [93:16]
+    |       |       |   |   `--LITERAL_DEFAULT -> default [93:16]
+    |       |       |   |       `--COLON -> : [93:23]
+    |       |       |   |--SINGLE_LINE_COMMENT -> // [94:17]
+    |       |       |   |   `--COMMENT_CONTENT ->  comment\n [94:19]
+    |       |       |   `--RCURLY -> } [95:12]
+    |       |       `--RCURLY -> } [97:8]
+    |       `--RCURLY -> } [98:4]
+    |--METHOD_DEF -> METHOD_DEF [100:4]
+    |   |--MODIFIERS -> MODIFIERS [100:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [99:4]
+    |   |   |   |--COMMENT_CONTENT -> * Single line javadoc here  [99:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [99:32]
+    |   |   `--LITERAL_PUBLIC -> public [100:4]
+    |   |--TYPE -> TYPE [100:11]
+    |   |   `--LITERAL_VOID -> void [100:11]
+    |   |--IDENT -> fooDotInCaseBlock [100:16]
+    |   |--LPAREN -> ( [100:33]
+    |   |--PARAMETERS -> PARAMETERS [100:34]
+    |   |--RPAREN -> ) [100:34]
+    |   `--SLIST -> { [100:36]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [101:8]
+    |       |   |--MODIFIERS -> MODIFIERS [101:8]
+    |       |   |--TYPE -> TYPE [101:8]
+    |       |   |   `--LITERAL_INT -> int [101:8]
+    |       |   |--IDENT -> i [101:12]
+    |       |   `--ASSIGN -> = [101:14]
+    |       |       `--EXPR -> EXPR [101:16]
+    |       |           `--NUM_INT -> 0 [101:16]
+    |       |--SEMI -> ; [101:17]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [102:8]
+    |       |   |--MODIFIERS -> MODIFIERS [102:8]
+    |       |   |--TYPE -> TYPE [102:8]
+    |       |   |   `--IDENT -> String [102:8]
+    |       |   |--IDENT -> s [102:15]
+    |       |   `--ASSIGN -> = [102:17]
+    |       |       `--EXPR -> EXPR [102:19]
+    |       |           `--STRING_LITERAL -> "" [102:19]
+    |       |--SEMI -> ; [102:21]
+    |       |--LITERAL_SWITCH -> switch [104:8]
+    |       |   |--LPAREN -> ( [104:15]
+    |       |   |--EXPR -> EXPR [104:16]
+    |       |   |   `--IDENT -> i [104:16]
+    |       |   |--RPAREN -> ) [104:17]
+    |       |   |--LCURLY -> { [104:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [105:12]
+    |       |   |   |--LITERAL_CASE -> case [105:12]
+    |       |   |   |   |--EXPR -> EXPR [105:17]
+    |       |   |   |   |   `--UNARY_MINUS -> - [105:17]
+    |       |   |   |   |       `--NUM_INT -> 2 [105:18]
+    |       |   |   |   `--COLON -> : [105:19]
+    |       |   |   `--SLIST -> SLIST [107:17]
+    |       |   |       |--EXPR -> EXPR [107:17]
+    |       |   |       |   `--POST_INC -> ++ [107:17]
+    |       |   |       |       |--SINGLE_LINE_COMMENT -> // [106:16]
+    |       |   |       |       |   `--COMMENT_CONTENT ->  what\n [106:18]
+    |       |   |       |       `--IDENT -> i [107:16]
+    |       |   |       `--SEMI -> ; [107:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [109:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [108:16]
+    |       |   |   |   `--COMMENT_CONTENT ->  no break here\n [108:18]
+    |       |   |   |--LITERAL_CASE -> case [109:12]
+    |       |   |   |   |--EXPR -> EXPR [109:17]
+    |       |   |   |   |   `--NUM_INT -> 0 [109:17]
+    |       |   |   |   `--COLON -> : [109:18]
+    |       |   |   `--SLIST -> SLIST [111:25]
+    |       |   |       |--EXPR -> EXPR [111:25]
+    |       |   |       |   `--METHOD_CALL -> ( [111:25]
+    |       |   |       |       |--DOT -> . [111:17]
+    |       |   |       |       |   |--SINGLE_LINE_COMMENT -> // [110:16]
+    |       |   |       |       |   |   `--COMMENT_CONTENT ->  what\n [110:18]
+    |       |   |       |       |   |--IDENT -> s [111:16]
+    |       |   |       |       |   `--IDENT -> indexOf [111:18]
+    |       |   |       |       |--ELIST -> ELIST [111:26]
+    |       |   |       |       |   `--EXPR -> EXPR [111:26]
+    |       |   |       |       |       `--STRING_LITERAL -> "ignore" [111:26]
+    |       |   |       |       `--RPAREN -> ) [111:34]
+    |       |   |       `--SEMI -> ; [111:35]
+    |       |   |--CASE_GROUP -> CASE_GROUP [113:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [112:16]
+    |       |   |   |   `--COMMENT_CONTENT ->  no break here\n [112:18]
+    |       |   |   |--LITERAL_CASE -> case [113:12]
+    |       |   |   |   |--EXPR -> EXPR [113:17]
+    |       |   |   |   |   `--UNARY_MINUS -> - [113:17]
+    |       |   |   |   |       `--NUM_INT -> 1 [113:18]
+    |       |   |   |   `--COLON -> : [113:19]
+    |       |   |   `--SLIST -> SLIST [115:26]
+    |       |   |       |--EXPR -> EXPR [115:26]
+    |       |   |       |   `--METHOD_CALL -> ( [115:26]
+    |       |   |       |       |--DOT -> . [115:18]
+    |       |   |       |       |   |--SINGLE_LINE_COMMENT -> // [114:17]
+    |       |   |       |       |   |   `--COMMENT_CONTENT ->  what\n [114:19]
+    |       |   |       |       |   |--IDENT -> s [115:17]
+    |       |   |       |       |   `--IDENT -> indexOf [115:19]
+    |       |   |       |       |--ELIST -> ELIST [115:27]
+    |       |   |       |       |   `--EXPR -> EXPR [115:27]
+    |       |   |       |       |       `--STRING_LITERAL -> "no way" [115:27]
+    |       |   |       |       `--RPAREN -> ) [115:35]
+    |       |   |       `--SEMI -> ; [115:36]
+    |       |   |--CASE_GROUP -> CASE_GROUP [117:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [116:15]
+    |       |   |   |   `--COMMENT_CONTENT ->  warn\n [116:17]
+    |       |   |   |--LITERAL_CASE -> case [117:12]
+    |       |   |   |   |--EXPR -> EXPR [117:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [117:17]
+    |       |   |   |   `--COLON -> : [117:18]
+    |       |   |   |--LITERAL_CASE -> case [118:12]
+    |       |   |   |   |--EXPR -> EXPR [118:17]
+    |       |   |   |   |   `--NUM_INT -> 2 [118:17]
+    |       |   |   |   `--COLON -> : [118:18]
+    |       |   |   `--SLIST -> SLIST [119:17]
+    |       |   |       |--EXPR -> EXPR [119:17]
+    |       |   |       |   `--POST_DEC -> -- [119:17]
+    |       |   |       |       `--IDENT -> i [119:16]
+    |       |   |       `--SEMI -> ; [119:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [121:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [120:16]
+    |       |   |   |   `--COMMENT_CONTENT ->  no break here\n [120:18]
+    |       |   |   |--LITERAL_CASE -> case [121:12]
+    |       |   |   |   |--EXPR -> EXPR [121:17]
+    |       |   |   |   |   `--NUM_INT -> 3 [121:17]
+    |       |   |   |   `--COLON -> : [121:18]
+    |       |   |   `--SLIST -> SLIST [121:20]
+    |       |   |       `--SLIST -> { [121:20]
+    |       |   |           `--RCURLY -> } [121:22]
+    |       |   |--SINGLE_LINE_COMMENT -> // [122:12]
+    |       |   |   `--COMMENT_CONTENT ->  fall through\n [122:14]
+    |       |   `--RCURLY -> } [125:8]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [127:8]
+    |       |   |--MODIFIERS -> MODIFIERS [127:8]
+    |       |   |--TYPE -> TYPE [127:8]
+    |       |   |   `--IDENT -> String [127:8]
+    |       |   |--IDENT -> breaks [127:15]
+    |       |   `--ASSIGN -> = [127:22]
+    |       |       `--EXPR -> EXPR [131:12]
+    |       |           |--SINGLE_LINE_COMMENT -> // [130:12]
+    |       |           |   `--COMMENT_CONTENT ->  middle\n [130:14]
+    |       |           `--PLUS -> + [131:12]
+    |       |               |--SINGLE_LINE_COMMENT -> // [128:8]
+    |       |               |   `--COMMENT_CONTENT ->  warn\n [128:10]
+    |       |               |--PLUS -> + [129:12]
+    |       |               |   |--STRING_LITERAL -> "" [127:24]
+    |       |               |   `--STRING_LITERAL -> "</table>" [129:14]
+    |       |               `--STRING_LITERAL -> "" [131:14]
+    |       |--SINGLE_LINE_COMMENT -> // [132:8]
+    |       |   `--COMMENT_CONTENT ->  end\n [132:10]
+    |       |--SEMI -> ; [133:8]
+    |       `--RCURLY -> } [134:4]
+    |--METHOD_DEF -> METHOD_DEF [140:4]
+    |   |--MODIFIERS -> MODIFIERS [140:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [136:4]
+    |   |   |   |--COMMENT_CONTENT -> *\n     * Javadoc here.\n     *\n      [136:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [139:5]
+    |   |   `--LITERAL_PUBLIC -> public [140:4]
+    |   |--TYPE -> TYPE [140:11]
+    |   |   `--LITERAL_VOID -> void [140:11]
+    |   |--IDENT -> foo2 [140:16]
+    |   |--LPAREN -> ( [140:20]
+    |   |--PARAMETERS -> PARAMETERS [140:21]
+    |   |--RPAREN -> ) [140:21]
+    |   `--SLIST -> { [140:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [141:8]
+    |       |   |--MODIFIERS -> MODIFIERS [141:8]
+    |       |   |--TYPE -> TYPE [141:8]
+    |       |   |   `--LITERAL_INT -> int [141:8]
+    |       |   |--IDENT -> a [141:12]
+    |       |   `--ASSIGN -> = [141:14]
+    |       |       `--EXPR -> EXPR [141:16]
+    |       |           `--NUM_INT -> 1 [141:16]
+    |       |--SEMI -> ; [141:17]
+    |       |--LITERAL_SWITCH -> switch [142:8]
+    |       |   |--LPAREN -> ( [142:15]
+    |       |   |--EXPR -> EXPR [142:16]
+    |       |   |   `--IDENT -> a [142:16]
+    |       |   |--RPAREN -> ) [142:17]
+    |       |   |--LCURLY -> { [142:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [143:12]
+    |       |   |   |--LITERAL_CASE -> case [143:12]
+    |       |   |   |   |--EXPR -> EXPR [143:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [143:17]
+    |       |   |   |   |--BLOCK_COMMENT_BEGIN -> /* [143:18]
+    |       |   |   |   |   |--COMMENT_CONTENT -> block comment\n             [143:20]
+    |       |   |   |   |   `--BLOCK_COMMENT_END -> */ [144:12]
+    |       |   |   |   `--COLON -> : [144:14]
+    |       |   |   `--LITERAL_DEFAULT -> default [145:12]
+    |       |   |       `--COLON -> : [145:19]
+    |       |   |--SINGLE_LINE_COMMENT -> // [146:4]
+    |       |   |   `--COMMENT_CONTENT ->  warn\n [146:6]
+    |       |   `--RCURLY -> } [147:8]
+    |       `--RCURLY -> } [148:4]
+    |--METHOD_DEF -> METHOD_DEF [150:4]
+    |   |--MODIFIERS -> MODIFIERS [150:4]
+    |   |   `--LITERAL_PUBLIC -> public [150:4]
+    |   |--TYPE -> TYPE [150:11]
+    |   |   `--LITERAL_VOID -> void [150:11]
+    |   |--IDENT -> foo3 [150:16]
+    |   |--LPAREN -> ( [150:20]
+    |   |--PARAMETERS -> PARAMETERS [150:21]
+    |   |--RPAREN -> ) [150:21]
+    |   `--SLIST -> { [150:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [151:8]
+    |       |   |--MODIFIERS -> MODIFIERS [151:8]
+    |       |   |--TYPE -> TYPE [151:8]
+    |       |   |   `--LITERAL_INT -> int [151:8]
+    |       |   |--IDENT -> a [151:12]
+    |       |   `--ASSIGN -> = [151:14]
+    |       |       `--EXPR -> EXPR [151:39]
+    |       |           |--BLOCK_COMMENT_BEGIN -> /* [151:15]
+    |       |           |   |--COMMENT_CONTENT -> Block comment here  [151:17]
+    |       |           |   `--BLOCK_COMMENT_END -> */ [151:35]
+    |       |           `--NUM_INT -> 1 [151:39]
+    |       |--SEMI -> ; [151:40]
+    |       |--LITERAL_SWITCH -> switch [152:8]
+    |       |   |--LPAREN -> ( [152:15]
+    |       |   |--EXPR -> EXPR [152:16]
+    |       |   |   `--IDENT -> a [152:16]
+    |       |   |--RPAREN -> ) [152:17]
+    |       |   |--LCURLY -> { [152:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [153:12]
+    |       |   |   |--LITERAL_CASE -> case [153:12]
+    |       |   |   |   |--EXPR -> EXPR [153:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [153:17]
+    |       |   |   |   `--COLON -> : [153:18]
+    |       |   |   `--LITERAL_DEFAULT -> default [154:12]
+    |       |   |       `--COLON -> : [154:19]
+    |       |   |--SINGLE_LINE_COMMENT -> // [156:16]
+    |       |   |   `--COMMENT_CONTENT ->  comment\n [156:18]
+    |       |   `--RCURLY -> } [157:8]
+    |       `--RCURLY -> } [158:4]
+    |--METHOD_DEF -> METHOD_DEF [160:4]
+    |   |--MODIFIERS -> MODIFIERS [160:4]
+    |   |   `--LITERAL_PUBLIC -> public [160:4]
+    |   |--TYPE -> TYPE [160:11]
+    |   |   `--LITERAL_VOID -> void [160:11]
+    |   |--IDENT -> foo4 [160:16]
+    |   |--LPAREN -> ( [160:20]
+    |   |--PARAMETERS -> PARAMETERS [160:21]
+    |   |--RPAREN -> ) [160:21]
+    |   `--SLIST -> { [160:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [161:8]
+    |       |   |--MODIFIERS -> MODIFIERS [161:8]
+    |       |   |--TYPE -> TYPE [161:8]
+    |       |   |   `--LITERAL_INT -> int [161:8]
+    |       |   |--IDENT -> a [161:12]
+    |       |   `--ASSIGN -> = [161:14]
+    |       |       `--EXPR -> EXPR [161:16]
+    |       |           `--NUM_INT -> 1 [161:16]
+    |       |--SEMI -> ; [161:17]
+    |       |--LITERAL_SWITCH -> switch [162:8]
+    |       |   |--LPAREN -> ( [162:15]
+    |       |   |--EXPR -> EXPR [162:16]
+    |       |   |   `--IDENT -> a [162:16]
+    |       |   |--RPAREN -> ) [162:17]
+    |       |   |--LCURLY -> { [162:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [163:12]
+    |       |   |   |--LITERAL_CASE -> case [163:12]
+    |       |   |   |   |--EXPR -> EXPR [163:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [163:17]
+    |       |   |   |   `--COLON -> : [163:18]
+    |       |   |   `--SLIST -> SLIST [164:16]
+    |       |   |       |--VARIABLE_DEF -> VARIABLE_DEF [164:16]
+    |       |   |       |   |--MODIFIERS -> MODIFIERS [164:16]
+    |       |   |       |   |--TYPE -> TYPE [164:16]
+    |       |   |       |   |   `--LITERAL_INT -> int [164:16]
+    |       |   |       |   `--IDENT -> b [164:20]
+    |       |   |       `--SEMI -> ; [164:21]
+    |       |   |--CASE_GROUP -> CASE_GROUP [166:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [165:18]
+    |       |   |   |   `--COMMENT_CONTENT ->  warn\n [165:20]
+    |       |   |   `--LITERAL_DEFAULT -> default [166:12]
+    |       |   |       `--COLON -> : [166:19]
+    |       |   `--RCURLY -> } [167:8]
+    |       `--RCURLY -> } [168:4]
+    |--METHOD_DEF -> METHOD_DEF [170:4]
+    |   |--MODIFIERS -> MODIFIERS [170:4]
+    |   |   `--LITERAL_PUBLIC -> public [170:4]
+    |   |--TYPE -> TYPE [170:11]
+    |   |   `--LITERAL_VOID -> void [170:11]
+    |   |--IDENT -> foo5 [170:16]
+    |   |--LPAREN -> ( [170:20]
+    |   |--PARAMETERS -> PARAMETERS [170:21]
+    |   |--RPAREN -> ) [170:21]
+    |   `--SLIST -> { [170:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [171:8]
+    |       |   |--MODIFIERS -> MODIFIERS [171:8]
+    |       |   |--TYPE -> TYPE [171:8]
+    |       |   |   `--LITERAL_INT -> int [171:8]
+    |       |   |--IDENT -> a [171:12]
+    |       |   `--ASSIGN -> = [171:14]
+    |       |       `--EXPR -> EXPR [171:16]
+    |       |           `--NUM_INT -> 1 [171:16]
+    |       |--SEMI -> ; [171:17]
+    |       |--LITERAL_SWITCH -> switch [172:8]
+    |       |   |--LPAREN -> ( [172:15]
+    |       |   |--EXPR -> EXPR [172:16]
+    |       |   |   `--IDENT -> a [172:16]
+    |       |   |--RPAREN -> ) [172:17]
+    |       |   |--LCURLY -> { [172:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [173:12]
+    |       |   |   |--LITERAL_CASE -> case [173:12]
+    |       |   |   |   |--EXPR -> EXPR [173:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [173:17]
+    |       |   |   |   `--COLON -> : [173:18]
+    |       |   |   `--SLIST -> SLIST [174:16]
+    |       |   |       |--VARIABLE_DEF -> VARIABLE_DEF [174:16]
+    |       |   |       |   |--MODIFIERS -> MODIFIERS [174:16]
+    |       |   |       |   |--TYPE -> TYPE [174:16]
+    |       |   |       |   |   `--LITERAL_INT -> int [174:16]
+    |       |   |       |   `--IDENT -> b [174:20]
+    |       |   |       `--SEMI -> ; [174:21]
+    |       |   |--CASE_GROUP -> CASE_GROUP [176:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [175:12]
+    |       |   |   |   `--COMMENT_CONTENT ->  comment\n [175:14]
+    |       |   |   `--LITERAL_DEFAULT -> default [176:12]
+    |       |   |       `--COLON -> : [176:19]
+    |       |   `--RCURLY -> } [177:8]
+    |       `--RCURLY -> } [178:4]
+    |--METHOD_DEF -> METHOD_DEF [180:4]
+    |   |--MODIFIERS -> MODIFIERS [180:4]
+    |   |   `--LITERAL_PUBLIC -> public [180:4]
+    |   |--TYPE -> TYPE [180:11]
+    |   |   `--LITERAL_VOID -> void [180:11]
+    |   |--IDENT -> foo6 [180:16]
+    |   |--LPAREN -> ( [180:20]
+    |   |--PARAMETERS -> PARAMETERS [180:21]
+    |   |--RPAREN -> ) [180:21]
+    |   `--SLIST -> { [180:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [181:8]
+    |       |   |--MODIFIERS -> MODIFIERS [181:8]
+    |       |   |--TYPE -> TYPE [181:8]
+    |       |   |   `--LITERAL_INT -> int [181:8]
+    |       |   |--IDENT -> a [181:12]
+    |       |   `--ASSIGN -> = [181:14]
+    |       |       `--EXPR -> EXPR [181:16]
+    |       |           `--NUM_INT -> 1 [181:16]
+    |       |--SEMI -> ; [181:17]
+    |       |--LITERAL_SWITCH -> switch [182:8]
+    |       |   |--LPAREN -> ( [182:15]
+    |       |   |--EXPR -> EXPR [182:16]
+    |       |   |   `--IDENT -> a [182:16]
+    |       |   |--RPAREN -> ) [182:17]
+    |       |   |--LCURLY -> { [182:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [183:12]
+    |       |   |   |--LITERAL_CASE -> case [183:12]
+    |       |   |   |   |--EXPR -> EXPR [183:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [183:17]
+    |       |   |   |   `--COLON -> : [183:18]
+    |       |   |   `--SLIST -> SLIST [184:16]
+    |       |   |       |--VARIABLE_DEF -> VARIABLE_DEF [184:16]
+    |       |   |       |   |--MODIFIERS -> MODIFIERS [184:16]
+    |       |   |       |   |--TYPE -> TYPE [184:16]
+    |       |   |       |   |   `--LITERAL_INT -> int [184:16]
+    |       |   |       |   `--IDENT -> b [184:20]
+    |       |   |       `--SEMI -> ; [184:21]
+    |       |   |--CASE_GROUP -> CASE_GROUP [186:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [185:16]
+    |       |   |   |   `--COMMENT_CONTENT ->  comment\n [185:18]
+    |       |   |   `--LITERAL_DEFAULT -> default [186:12]
+    |       |   |       `--COLON -> : [186:19]
+    |       |   `--RCURLY -> } [187:8]
+    |       `--RCURLY -> } [188:4]
+    |--METHOD_DEF -> METHOD_DEF [190:4]
+    |   |--MODIFIERS -> MODIFIERS [190:4]
+    |   |   `--LITERAL_PUBLIC -> public [190:4]
+    |   |--TYPE -> TYPE [190:11]
+    |   |   `--LITERAL_VOID -> void [190:11]
+    |   |--IDENT -> foo7 [190:16]
+    |   |--LPAREN -> ( [190:20]
+    |   |--PARAMETERS -> PARAMETERS [190:21]
+    |   |--RPAREN -> ) [190:21]
+    |   `--SLIST -> { [190:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [191:8]
+    |       |   |--MODIFIERS -> MODIFIERS [191:8]
+    |       |   |--TYPE -> TYPE [191:8]
+    |       |   |   `--LITERAL_INT -> int [191:8]
+    |       |   |--IDENT -> a [191:12]
+    |       |   `--ASSIGN -> = [191:14]
+    |       |       `--EXPR -> EXPR [191:16]
+    |       |           `--NUM_INT -> 2 [191:16]
+    |       |--SEMI -> ; [191:17]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [192:8]
+    |       |   |--MODIFIERS -> MODIFIERS [192:8]
+    |       |   |--TYPE -> TYPE [192:8]
+    |       |   |   `--IDENT -> String [192:8]
+    |       |   |--IDENT -> s [192:15]
+    |       |   `--ASSIGN -> = [192:17]
+    |       |       `--EXPR -> EXPR [192:19]
+    |       |           `--STRING_LITERAL -> "" [192:19]
+    |       |--SEMI -> ; [192:21]
+    |       |--LITERAL_SWITCH -> switch [193:8]
+    |       |   |--LPAREN -> ( [193:15]
+    |       |   |--EXPR -> EXPR [193:16]
+    |       |   |   `--IDENT -> a [193:16]
+    |       |   |--RPAREN -> ) [193:17]
+    |       |   |--LCURLY -> { [193:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [197:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [194:12]
+    |       |   |   |   `--COMMENT_CONTENT ->  comment\n [194:14]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [195:12]
+    |       |   |   |   `--COMMENT_CONTENT ->  comment\n [195:14]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [196:12]
+    |       |   |   |   `--COMMENT_CONTENT ->  comment\n [196:14]
+    |       |   |   |--LITERAL_CASE -> case [197:12]
+    |       |   |   |   |--EXPR -> EXPR [197:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [197:17]
+    |       |   |   |   `--COLON -> : [197:18]
+    |       |   |   |--LITERAL_CASE -> case [198:12]
+    |       |   |   |   |--EXPR -> EXPR [198:17]
+    |       |   |   |   |   `--NUM_INT -> 2 [198:17]
+    |       |   |   |   `--COLON -> : [198:18]
+    |       |   |   `--SLIST -> SLIST [201:20]
+    |       |   |       |--EXPR -> EXPR [201:20]
+    |       |   |       |   `--METHOD_CALL -> ( [201:20]
+    |       |   |       |       |--SINGLE_LINE_COMMENT -> // [199:16]
+    |       |   |       |       |   `--COMMENT_CONTENT ->  comment\n [199:18]
+    |       |   |       |       |--SINGLE_LINE_COMMENT -> // [200:16]
+    |       |   |       |       |   `--COMMENT_CONTENT ->  comment\n [200:18]
+    |       |   |       |       |--IDENT -> foo1 [201:16]
+    |       |   |       |       |--ELIST -> ELIST [201:21]
+    |       |   |       |       `--RPAREN -> ) [201:21]
+    |       |   |       `--SEMI -> ; [201:22]
+    |       |   |--CASE_GROUP -> CASE_GROUP [203:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [202:16]
+    |       |   |   |   `--COMMENT_CONTENT ->  comment\n [202:18]
+    |       |   |   |--LITERAL_CASE -> case [203:12]
+    |       |   |   |   |--EXPR -> EXPR [203:17]
+    |       |   |   |   |   `--NUM_INT -> 3 [203:17]
+    |       |   |   |   `--COLON -> : [203:18]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [204:16]
+    |       |   |   |   `--COMMENT_CONTENT ->  comment\n [204:18]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [205:16]
+    |       |   |   |   `--COMMENT_CONTENT ->  comment\n [205:18]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [206:16]
+    |       |   |   |   `--COMMENT_CONTENT ->  comment\n [206:18]
+    |       |   |   |--LITERAL_CASE -> case [207:12]
+    |       |   |   |   |--EXPR -> EXPR [207:17]
+    |       |   |   |   |   `--NUM_INT -> 4 [207:17]
+    |       |   |   |   `--COLON -> : [207:18]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [208:4]
+    |       |   |   |   `--COMMENT_CONTENT ->  warn\n [208:6]
+    |       |   |   |--LITERAL_CASE -> case [209:12]
+    |       |   |   |   |--EXPR -> EXPR [209:17]
+    |       |   |   |   |   `--NUM_INT -> 5 [209:17]
+    |       |   |   |   `--COLON -> : [209:18]
+    |       |   |   `--SLIST -> SLIST [210:48]
+    |       |   |       |--EXPR -> EXPR [210:48]
+    |       |   |       |   `--METHOD_CALL -> ( [210:48]
+    |       |   |       |       |--DOT -> . [210:39]
+    |       |   |       |       |   |--METHOD_CALL -> ( [210:37]
+    |       |   |       |       |   |   |--DOT -> . [210:28]
+    |       |   |       |       |   |   |   |--METHOD_CALL -> ( [210:26]
+    |       |   |       |       |   |   |   |   |--DOT -> . [210:17]
+    |       |   |       |       |   |   |   |   |   |--IDENT -> s [210:16]
+    |       |   |       |       |   |   |   |   |   `--IDENT -> toString [210:18]
+    |       |   |       |       |   |   |   |   |--ELIST -> ELIST [210:27]
+    |       |   |       |       |   |   |   |   `--RPAREN -> ) [210:27]
+    |       |   |       |       |   |   |   `--IDENT -> toString [210:29]
+    |       |   |       |       |   |   |--ELIST -> ELIST [210:38]
+    |       |   |       |       |   |   `--RPAREN -> ) [210:38]
+    |       |   |       |       |   `--IDENT -> toString [210:40]
+    |       |   |       |       |--ELIST -> ELIST [210:49]
+    |       |   |       |       `--RPAREN -> ) [210:49]
+    |       |   |       `--SEMI -> ; [210:50]
+    |       |   |--CASE_GROUP -> CASE_GROUP [214:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [211:22]
+    |       |   |   |   `--COMMENT_CONTENT ->  warn\n [211:24]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [212:20]
+    |       |   |   |   `--COMMENT_CONTENT ->  warn\n [212:22]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [213:17]
+    |       |   |   |   `--COMMENT_CONTENT ->  warn\n [213:19]
+    |       |   |   `--LITERAL_DEFAULT -> default [214:12]
+    |       |   |       `--COLON -> : [214:19]
+    |       |   `--RCURLY -> } [215:8]
+    |       `--RCURLY -> } [216:4]
+    |--METHOD_DEF -> METHOD_DEF [218:4]
+    |   |--MODIFIERS -> MODIFIERS [218:4]
+    |   |   `--LITERAL_PUBLIC -> public [218:4]
+    |   |--TYPE -> TYPE [218:11]
+    |   |   `--LITERAL_VOID -> void [218:11]
+    |   |--IDENT -> foo8 [218:16]
+    |   |--LPAREN -> ( [218:20]
+    |   |--PARAMETERS -> PARAMETERS [218:21]
+    |   |--RPAREN -> ) [218:21]
+    |   `--SLIST -> { [218:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [219:8]
+    |       |   |--MODIFIERS -> MODIFIERS [219:8]
+    |       |   |--TYPE -> TYPE [219:8]
+    |       |   |   `--LITERAL_INT -> int [219:8]
+    |       |   |--IDENT -> a [219:12]
+    |       |   `--ASSIGN -> = [219:14]
+    |       |       `--EXPR -> EXPR [219:16]
+    |       |           `--NUM_INT -> 2 [219:16]
+    |       |--SEMI -> ; [219:17]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [220:8]
+    |       |   |--MODIFIERS -> MODIFIERS [220:8]
+    |       |   |--TYPE -> TYPE [220:8]
+    |       |   |   `--IDENT -> String [220:8]
+    |       |   |--IDENT -> s [220:15]
+    |       |   `--ASSIGN -> = [220:17]
+    |       |       `--EXPR -> EXPR [220:19]
+    |       |           `--STRING_LITERAL -> "" [220:19]
+    |       |--SEMI -> ; [220:21]
+    |       |--LITERAL_SWITCH -> switch [221:8]
+    |       |   |--LPAREN -> ( [221:15]
+    |       |   |--EXPR -> EXPR [221:16]
+    |       |   |   `--IDENT -> a [221:16]
+    |       |   |--RPAREN -> ) [221:17]
+    |       |   |--LCURLY -> { [221:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [225:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [222:12]
+    |       |   |   |   `--COMMENT_CONTENT ->  comment\n [222:14]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [223:12]
+    |       |   |   |   `--COMMENT_CONTENT ->  comment\n [223:14]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [224:12]
+    |       |   |   |   `--COMMENT_CONTENT ->  comment\n [224:14]
+    |       |   |   |--LITERAL_CASE -> case [225:12]
+    |       |   |   |   |--EXPR -> EXPR [225:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [225:17]
+    |       |   |   |   `--COLON -> : [225:18]
+    |       |   |   |--LITERAL_CASE -> case [226:12]
+    |       |   |   |   |--EXPR -> EXPR [226:17]
+    |       |   |   |   |   `--NUM_INT -> 2 [226:17]
+    |       |   |   |   `--COLON -> : [226:18]
+    |       |   |   `--SLIST -> SLIST [229:20]
+    |       |   |       |--EXPR -> EXPR [229:20]
+    |       |   |       |   `--METHOD_CALL -> ( [229:20]
+    |       |   |       |       |--SINGLE_LINE_COMMENT -> // [227:16]
+    |       |   |       |       |   `--COMMENT_CONTENT ->  comment\n [227:18]
+    |       |   |       |       |--SINGLE_LINE_COMMENT -> // [228:16]
+    |       |   |       |       |   `--COMMENT_CONTENT ->  comment\n [228:18]
+    |       |   |       |       |--IDENT -> foo1 [229:16]
+    |       |   |       |       |--ELIST -> ELIST [229:21]
+    |       |   |       |       `--RPAREN -> ) [229:21]
+    |       |   |       `--SEMI -> ; [229:22]
+    |       |   |--CASE_GROUP -> CASE_GROUP [231:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [230:16]
+    |       |   |   |   `--COMMENT_CONTENT ->  comment\n [230:18]
+    |       |   |   |--LITERAL_CASE -> case [231:12]
+    |       |   |   |   |--EXPR -> EXPR [231:17]
+    |       |   |   |   |   `--NUM_INT -> 3 [231:17]
+    |       |   |   |   `--COLON -> : [231:18]
+    |       |   |   `--SLIST -> SLIST [234:48]
+    |       |   |       |--EXPR -> EXPR [234:48]
+    |       |   |       |   `--METHOD_CALL -> ( [234:48]
+    |       |   |       |       |--DOT -> . [234:39]
+    |       |   |       |       |   |--METHOD_CALL -> ( [234:37]
+    |       |   |       |       |   |   |--DOT -> . [234:28]
+    |       |   |       |       |   |   |   |--METHOD_CALL -> ( [234:26]
+    |       |   |       |       |   |   |   |   |--DOT -> . [234:17]
+    |       |   |       |       |   |   |   |   |   |--SINGLE_LINE_COMMENT -> // [232:16]
+    |       |   |       |       |   |   |   |   |   |   `--COMMENT_CONTENT ->  comment\n [232:18]
+    |       |   |       |       |   |   |   |   |   |--SINGLE_LINE_COMMENT -> // [233:16]
+    |       |   |       |       |   |   |   |   |   |   `--COMMENT_CONTENT ->  comment\n [233:18]
+    |       |   |       |       |   |   |   |   |   |--IDENT -> s [234:16]
+    |       |   |       |       |   |   |   |   |   `--IDENT -> toString [234:18]
+    |       |   |       |       |   |   |   |   |--ELIST -> ELIST [234:27]
+    |       |   |       |       |   |   |   |   `--RPAREN -> ) [234:27]
+    |       |   |       |       |   |   |   `--IDENT -> toString [234:29]
+    |       |   |       |       |   |   |--ELIST -> ELIST [234:38]
+    |       |   |       |       |   |   `--RPAREN -> ) [234:38]
+    |       |   |       |       |   `--IDENT -> toString [234:40]
+    |       |   |       |       |--ELIST -> ELIST [234:49]
+    |       |   |       |       `--RPAREN -> ) [234:49]
+    |       |   |       `--SEMI -> ; [234:50]
+    |       |   |--CASE_GROUP -> CASE_GROUP [236:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [235:16]
+    |       |   |   |   `--COMMENT_CONTENT ->  comment\n [235:18]
+    |       |   |   |--LITERAL_CASE -> case [236:12]
+    |       |   |   |   |--EXPR -> EXPR [236:17]
+    |       |   |   |   |   `--NUM_INT -> 4 [236:17]
+    |       |   |   |   `--COLON -> : [236:18]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [237:6]
+    |       |   |   |   `--COMMENT_CONTENT ->  warn\n [237:8]
+    |       |   |   `--LITERAL_DEFAULT -> default [238:12]
+    |       |   |       `--COLON -> : [238:19]
+    |       |   `--RCURLY -> } [239:8]
+    |       `--RCURLY -> } [240:4]
+    |--METHOD_DEF -> METHOD_DEF [242:4]
+    |   |--MODIFIERS -> MODIFIERS [242:4]
+    |   |   `--LITERAL_PUBLIC -> public [242:4]
+    |   |--TYPE -> TYPE [242:11]
+    |   |   `--LITERAL_VOID -> void [242:11]
+    |   |--IDENT -> foo9 [242:16]
+    |   |--LPAREN -> ( [242:20]
+    |   |--PARAMETERS -> PARAMETERS [242:21]
+    |   |--RPAREN -> ) [242:21]
+    |   `--SLIST -> { [242:23]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [243:8]
+    |       |   |--MODIFIERS -> MODIFIERS [243:8]
+    |       |   |--TYPE -> TYPE [243:8]
+    |       |   |   `--LITERAL_INT -> int [243:8]
+    |       |   |--IDENT -> a [243:12]
+    |       |   `--ASSIGN -> = [243:14]
+    |       |       `--EXPR -> EXPR [243:16]
+    |       |           `--NUM_INT -> 5 [243:16]
+    |       |--SEMI -> ; [243:17]
+    |       |--LITERAL_SWITCH -> switch [244:8]
+    |       |   |--LPAREN -> ( [244:15]
+    |       |   |--EXPR -> EXPR [244:16]
+    |       |   |   `--IDENT -> a [244:16]
+    |       |   |--RPAREN -> ) [244:17]
+    |       |   |--LCURLY -> { [244:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [245:12]
+    |       |   |   |--LITERAL_CASE -> case [245:12]
+    |       |   |   |   |--EXPR -> EXPR [245:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [245:17]
+    |       |   |   |   `--COLON -> : [245:18]
+    |       |   |   `--LITERAL_CASE -> case [246:12]
+    |       |   |       |--EXPR -> EXPR [246:17]
+    |       |   |       |   `--NUM_INT -> 2 [246:17]
+    |       |   |       `--COLON -> : [246:18]
+    |       |   |--SINGLE_LINE_COMMENT -> // [247:16]
+    |       |   |   `--COMMENT_CONTENT ->  comment\n [247:18]
+    |       |   `--RCURLY -> } [248:8]
+    |       `--RCURLY -> } [249:4]
+    |--METHOD_DEF -> METHOD_DEF [251:4]
+    |   |--MODIFIERS -> MODIFIERS [251:4]
+    |   |   `--LITERAL_PUBLIC -> public [251:4]
+    |   |--TYPE -> TYPE [251:11]
+    |   |   `--LITERAL_VOID -> void [251:11]
+    |   |--IDENT -> foo10 [251:16]
+    |   |--LPAREN -> ( [251:21]
+    |   |--PARAMETERS -> PARAMETERS [251:22]
+    |   |--RPAREN -> ) [251:22]
+    |   `--SLIST -> { [251:24]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [252:8]
+    |       |   |--MODIFIERS -> MODIFIERS [252:8]
+    |       |   |--TYPE -> TYPE [252:8]
+    |       |   |   `--LITERAL_INT -> int [252:8]
+    |       |   |--IDENT -> a [252:12]
+    |       |   `--ASSIGN -> = [252:14]
+    |       |       `--EXPR -> EXPR [252:16]
+    |       |           `--NUM_INT -> 5 [252:16]
+    |       |--SEMI -> ; [252:17]
+    |       |--LITERAL_SWITCH -> switch [253:8]
+    |       |   |--LPAREN -> ( [253:15]
+    |       |   |--EXPR -> EXPR [253:16]
+    |       |   |   `--IDENT -> a [253:16]
+    |       |   |--RPAREN -> ) [253:17]
+    |       |   |--LCURLY -> { [253:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [254:12]
+    |       |   |   |--LITERAL_CASE -> case [254:12]
+    |       |   |   |   |--EXPR -> EXPR [254:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [254:17]
+    |       |   |   |   `--COLON -> : [254:18]
+    |       |   |   `--LITERAL_DEFAULT -> default [255:12]
+    |       |   |       `--COLON -> : [255:19]
+    |       |   |--SINGLE_LINE_COMMENT -> // [256:16]
+    |       |   |   `--COMMENT_CONTENT ->  comment\n [256:18]
+    |       |   `--RCURLY -> } [257:8]
+    |       `--RCURLY -> } [258:4]
+    |--METHOD_DEF -> METHOD_DEF [260:4]
+    |   |--MODIFIERS -> MODIFIERS [260:4]
+    |   |   `--LITERAL_PUBLIC -> public [260:4]
+    |   |--TYPE -> TYPE [260:11]
+    |   |   `--LITERAL_VOID -> void [260:11]
+    |   |--IDENT -> foo11 [260:16]
+    |   |--LPAREN -> ( [260:21]
+    |   |--PARAMETERS -> PARAMETERS [260:22]
+    |   |--RPAREN -> ) [260:22]
+    |   `--SLIST -> { [260:24]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [261:8]
+    |       |   |--MODIFIERS -> MODIFIERS [261:8]
+    |       |   |--TYPE -> TYPE [261:8]
+    |       |   |   `--LITERAL_INT -> int [261:8]
+    |       |   |--IDENT -> a [261:12]
+    |       |   `--ASSIGN -> = [261:14]
+    |       |       `--EXPR -> EXPR [261:16]
+    |       |           `--NUM_INT -> 5 [261:16]
+    |       |--SEMI -> ; [261:17]
+    |       |--LITERAL_SWITCH -> switch [262:8]
+    |       |   |--LPAREN -> ( [262:15]
+    |       |   |--EXPR -> EXPR [262:16]
+    |       |   |   `--IDENT -> a [262:16]
+    |       |   |--RPAREN -> ) [262:17]
+    |       |   |--LCURLY -> { [262:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [263:12]
+    |       |   |   |--LITERAL_CASE -> case [263:12]
+    |       |   |   |   |--EXPR -> EXPR [263:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [263:17]
+    |       |   |   |   `--COLON -> : [263:18]
+    |       |   |   `--LITERAL_CASE -> case [264:12]
+    |       |   |       |--EXPR -> EXPR [264:17]
+    |       |   |       |   `--NUM_INT -> 2 [264:17]
+    |       |   |       `--COLON -> : [264:18]
+    |       |   |--SINGLE_LINE_COMMENT -> // [265:16]
+    |       |   |   `--COMMENT_CONTENT ->  comment\n [265:18]
+    |       |   `--RCURLY -> } [266:8]
+    |       `--RCURLY -> } [267:4]
+    |--METHOD_DEF -> METHOD_DEF [269:4]
+    |   |--MODIFIERS -> MODIFIERS [269:4]
+    |   |   `--LITERAL_PUBLIC -> public [269:4]
+    |   |--TYPE -> TYPE [269:11]
+    |   |   `--LITERAL_VOID -> void [269:11]
+    |   |--IDENT -> foo12 [269:16]
+    |   |--LPAREN -> ( [269:21]
+    |   |--PARAMETERS -> PARAMETERS [269:22]
+    |   |--RPAREN -> ) [269:22]
+    |   `--SLIST -> { [269:24]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [270:8]
+    |       |   |--MODIFIERS -> MODIFIERS [270:8]
+    |       |   |--TYPE -> TYPE [270:8]
+    |       |   |   `--LITERAL_INT -> int [270:8]
+    |       |   |--IDENT -> a [270:12]
+    |       |   `--ASSIGN -> = [270:14]
+    |       |       `--EXPR -> EXPR [270:16]
+    |       |           `--NUM_INT -> 5 [270:16]
+    |       |--SEMI -> ; [270:17]
+    |       |--LITERAL_SWITCH -> switch [271:8]
+    |       |   |--LPAREN -> ( [271:15]
+    |       |   |--EXPR -> EXPR [271:16]
+    |       |   |   `--IDENT -> a [271:16]
+    |       |   |--RPAREN -> ) [271:17]
+    |       |   |--LCURLY -> { [271:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [273:12]
+    |       |   |   |--SINGLE_LINE_COMMENT -> // [272:12]
+    |       |   |   |   `--COMMENT_CONTENT ->  comment\n [272:14]
+    |       |   |   `--LITERAL_CASE -> case [273:12]
+    |       |   |       |--EXPR -> EXPR [273:17]
+    |       |   |       |   `--NUM_INT -> 1 [273:17]
+    |       |   |       `--COLON -> : [273:18]
+    |       |   `--RCURLY -> } [274:8]
+    |       `--RCURLY -> } [275:4]
+    `--RCURLY -> } [276:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickyYield.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickyYield.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickyYield.java
@@ -0,0 +1,14 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import java.util.Iterator;
+import java.util.function.Function;
+
+public class InputAntlr4AstRegressionTrickyYield<T1> {
+    public Iterator<T1> yield() {
+        return yield(Function.identity());
+    }
+
+    private static <T, T1> Iterator<T1> yield(Function<T,T> identity) {
+        return null;
+    }
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickyYield.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickyYield.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTrickyYield.txt
@@ -0,0 +1,115 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+IMPORT -> import [3:0]
+|--DOT -> . [3:16]
+|   |--DOT -> . [3:11]
+|   |   |--IDENT -> java [3:7]
+|   |   `--IDENT -> util [3:12]
+|   `--IDENT -> Iterator [3:17]
+`--SEMI -> ; [3:25]
+IMPORT -> import [4:0]
+|--DOT -> . [4:25]
+|   |--DOT -> . [4:16]
+|   |   |--DOT -> . [4:11]
+|   |   |   |--IDENT -> java [4:7]
+|   |   |   `--IDENT -> util [4:12]
+|   |   `--IDENT -> function [4:17]
+|   `--IDENT -> Function [4:26]
+`--SEMI -> ; [4:34]
+CLASS_DEF -> CLASS_DEF [6:0]
+|--MODIFIERS -> MODIFIERS [6:0]
+|   `--LITERAL_PUBLIC -> public [6:0]
+|--LITERAL_CLASS -> class [6:7]
+|--IDENT -> InputAntlr4AstRegressionTrickyYield [6:13]
+|--TYPE_PARAMETERS -> TYPE_PARAMETERS [6:48]
+|   |--GENERIC_START -> < [6:48]
+|   |--TYPE_PARAMETER -> TYPE_PARAMETER [6:49]
+|   |   `--IDENT -> T1 [6:49]
+|   `--GENERIC_END -> > [6:51]
+`--OBJBLOCK -> OBJBLOCK [6:53]
+    |--LCURLY -> { [6:53]
+    |--METHOD_DEF -> METHOD_DEF [7:4]
+    |   |--MODIFIERS -> MODIFIERS [7:4]
+    |   |   `--LITERAL_PUBLIC -> public [7:4]
+    |   |--TYPE -> TYPE [7:11]
+    |   |   |--IDENT -> Iterator [7:11]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [7:19]
+    |   |       |--GENERIC_START -> < [7:19]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [7:20]
+    |   |       |   `--IDENT -> T1 [7:20]
+    |   |       `--GENERIC_END -> > [7:22]
+    |   |--IDENT -> yield [7:24]
+    |   |--LPAREN -> ( [7:29]
+    |   |--PARAMETERS -> PARAMETERS [7:30]
+    |   |--RPAREN -> ) [7:30]
+    |   `--SLIST -> { [7:32]
+    |       |--LITERAL_RETURN -> return [8:8]
+    |       |   |--EXPR -> EXPR [8:20]
+    |       |   |   `--METHOD_CALL -> ( [8:20]
+    |       |   |       |--IDENT -> yield [8:15]
+    |       |   |       |--ELIST -> ELIST [8:38]
+    |       |   |       |   `--EXPR -> EXPR [8:38]
+    |       |   |       |       `--METHOD_CALL -> ( [8:38]
+    |       |   |       |           |--DOT -> . [8:29]
+    |       |   |       |           |   |--IDENT -> Function [8:21]
+    |       |   |       |           |   `--IDENT -> identity [8:30]
+    |       |   |       |           |--ELIST -> ELIST [8:39]
+    |       |   |       |           `--RPAREN -> ) [8:39]
+    |       |   |       `--RPAREN -> ) [8:40]
+    |       |   `--SEMI -> ; [8:41]
+    |       `--RCURLY -> } [9:4]
+    |--METHOD_DEF -> METHOD_DEF [11:4]
+    |   |--MODIFIERS -> MODIFIERS [11:4]
+    |   |   |--LITERAL_PRIVATE -> private [11:4]
+    |   |   `--LITERAL_STATIC -> static [11:12]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [11:19]
+    |   |   |--GENERIC_START -> < [11:19]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [11:20]
+    |   |   |   `--IDENT -> T [11:20]
+    |   |   |--COMMA -> , [11:21]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [11:23]
+    |   |   |   `--IDENT -> T1 [11:23]
+    |   |   `--GENERIC_END -> > [11:25]
+    |   |--TYPE -> TYPE [11:27]
+    |   |   |--IDENT -> Iterator [11:27]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [11:35]
+    |   |       |--GENERIC_START -> < [11:35]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [11:36]
+    |   |       |   `--IDENT -> T1 [11:36]
+    |   |       `--GENERIC_END -> > [11:38]
+    |   |--IDENT -> yield [11:40]
+    |   |--LPAREN -> ( [11:45]
+    |   |--PARAMETERS -> PARAMETERS [11:46]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [11:46]
+    |   |       |--MODIFIERS -> MODIFIERS [11:46]
+    |   |       |--TYPE -> TYPE [11:46]
+    |   |       |   |--IDENT -> Function [11:46]
+    |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [11:54]
+    |   |       |       |--GENERIC_START -> < [11:54]
+    |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [11:55]
+    |   |       |       |   `--IDENT -> T [11:55]
+    |   |       |       |--COMMA -> , [11:56]
+    |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [11:57]
+    |   |       |       |   `--IDENT -> T [11:57]
+    |   |       |       `--GENERIC_END -> > [11:58]
+    |   |       `--IDENT -> identity [11:60]
+    |   |--RPAREN -> ) [11:68]
+    |   `--SLIST -> { [11:70]
+    |       |--LITERAL_RETURN -> return [12:8]
+    |       |   |--EXPR -> EXPR [12:15]
+    |       |   |   `--LITERAL_NULL -> null [12:15]
+    |       |   `--SEMI -> ; [12:19]
+    |       `--RCURLY -> } [13:4]
+    `--RCURLY -> } [14:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTypeParams.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTypeParams.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTypeParams.java
@@ -0,0 +1,24 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import java.lang.reflect.TypeVariable;
+import java.util.List;
+
+public class InputAntlr4AstRegressionTypeParams {
+    public TypeVariable<Class<List<String>[]>>[] getTypeParameters3() {
+        return null;
+    }
+
+    TypeVariable<Class<List<String>[]>>[] tester3;
+
+    public TypeVariable<Class<String>>[] getTypeParameters2() {
+        return null;
+    }
+
+    TypeVariable<Class<String>>[] tester2;
+
+    public TypeVariable<Class>[] getTypeParameters1() {
+        return null;
+    }
+
+    TypeVariable<Class>[] tester1;
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTypeParams.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTypeParams.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionTypeParams.txt
@@ -0,0 +1,177 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+IMPORT -> import [3:0]
+|--DOT -> . [3:24]
+|   |--DOT -> . [3:16]
+|   |   |--DOT -> . [3:11]
+|   |   |   |--IDENT -> java [3:7]
+|   |   |   `--IDENT -> lang [3:12]
+|   |   `--IDENT -> reflect [3:17]
+|   `--IDENT -> TypeVariable [3:25]
+`--SEMI -> ; [3:37]
+IMPORT -> import [4:0]
+|--DOT -> . [4:16]
+|   |--DOT -> . [4:11]
+|   |   |--IDENT -> java [4:7]
+|   |   `--IDENT -> util [4:12]
+|   `--IDENT -> List [4:17]
+`--SEMI -> ; [4:21]
+CLASS_DEF -> CLASS_DEF [6:0]
+|--MODIFIERS -> MODIFIERS [6:0]
+|   `--LITERAL_PUBLIC -> public [6:0]
+|--LITERAL_CLASS -> class [6:7]
+|--IDENT -> InputAntlr4AstRegressionTypeParams [6:13]
+`--OBJBLOCK -> OBJBLOCK [6:48]
+    |--LCURLY -> { [6:48]
+    |--METHOD_DEF -> METHOD_DEF [7:4]
+    |   |--MODIFIERS -> MODIFIERS [7:4]
+    |   |   `--LITERAL_PUBLIC -> public [7:4]
+    |   |--TYPE -> TYPE [7:11]
+    |   |   |--IDENT -> TypeVariable [7:11]
+    |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [7:23]
+    |   |   |   |--GENERIC_START -> < [7:23]
+    |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [7:24]
+    |   |   |   |   |--IDENT -> Class [7:24]
+    |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [7:29]
+    |   |   |   |       |--GENERIC_START -> < [7:29]
+    |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [7:30]
+    |   |   |   |       |   |--IDENT -> List [7:30]
+    |   |   |   |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [7:34]
+    |   |   |   |       |   |   |--GENERIC_START -> < [7:34]
+    |   |   |   |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [7:35]
+    |   |   |   |       |   |   |   `--IDENT -> String [7:35]
+    |   |   |   |       |   |   `--GENERIC_END -> > [7:41]
+    |   |   |   |       |   `--ARRAY_DECLARATOR -> [ [7:42]
+    |   |   |   |       |       `--RBRACK -> ] [7:43]
+    |   |   |   |       `--GENERIC_END -> > [7:44]
+    |   |   |   `--GENERIC_END -> > [7:45]
+    |   |   `--ARRAY_DECLARATOR -> [ [7:46]
+    |   |       `--RBRACK -> ] [7:47]
+    |   |--IDENT -> getTypeParameters3 [7:49]
+    |   |--LPAREN -> ( [7:67]
+    |   |--PARAMETERS -> PARAMETERS [7:68]
+    |   |--RPAREN -> ) [7:68]
+    |   `--SLIST -> { [7:70]
+    |       |--LITERAL_RETURN -> return [8:8]
+    |       |   |--EXPR -> EXPR [8:15]
+    |       |   |   `--LITERAL_NULL -> null [8:15]
+    |       |   `--SEMI -> ; [8:19]
+    |       `--RCURLY -> } [9:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [11:4]
+    |   |--MODIFIERS -> MODIFIERS [11:4]
+    |   |--TYPE -> TYPE [11:4]
+    |   |   |--IDENT -> TypeVariable [11:4]
+    |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [11:16]
+    |   |   |   |--GENERIC_START -> < [11:16]
+    |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [11:17]
+    |   |   |   |   |--IDENT -> Class [11:17]
+    |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [11:22]
+    |   |   |   |       |--GENERIC_START -> < [11:22]
+    |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [11:23]
+    |   |   |   |       |   |--IDENT -> List [11:23]
+    |   |   |   |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [11:27]
+    |   |   |   |       |   |   |--GENERIC_START -> < [11:27]
+    |   |   |   |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [11:28]
+    |   |   |   |       |   |   |   `--IDENT -> String [11:28]
+    |   |   |   |       |   |   `--GENERIC_END -> > [11:34]
+    |   |   |   |       |   `--ARRAY_DECLARATOR -> [ [11:35]
+    |   |   |   |       |       `--RBRACK -> ] [11:36]
+    |   |   |   |       `--GENERIC_END -> > [11:37]
+    |   |   |   `--GENERIC_END -> > [11:38]
+    |   |   `--ARRAY_DECLARATOR -> [ [11:39]
+    |   |       `--RBRACK -> ] [11:40]
+    |   |--IDENT -> tester3 [11:42]
+    |   `--SEMI -> ; [11:49]
+    |--METHOD_DEF -> METHOD_DEF [13:4]
+    |   |--MODIFIERS -> MODIFIERS [13:4]
+    |   |   `--LITERAL_PUBLIC -> public [13:4]
+    |   |--TYPE -> TYPE [13:11]
+    |   |   |--IDENT -> TypeVariable [13:11]
+    |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [13:23]
+    |   |   |   |--GENERIC_START -> < [13:23]
+    |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [13:24]
+    |   |   |   |   |--IDENT -> Class [13:24]
+    |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [13:29]
+    |   |   |   |       |--GENERIC_START -> < [13:29]
+    |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [13:30]
+    |   |   |   |       |   `--IDENT -> String [13:30]
+    |   |   |   |       `--GENERIC_END -> > [13:36]
+    |   |   |   `--GENERIC_END -> > [13:37]
+    |   |   `--ARRAY_DECLARATOR -> [ [13:38]
+    |   |       `--RBRACK -> ] [13:39]
+    |   |--IDENT -> getTypeParameters2 [13:41]
+    |   |--LPAREN -> ( [13:59]
+    |   |--PARAMETERS -> PARAMETERS [13:60]
+    |   |--RPAREN -> ) [13:60]
+    |   `--SLIST -> { [13:62]
+    |       |--LITERAL_RETURN -> return [14:8]
+    |       |   |--EXPR -> EXPR [14:15]
+    |       |   |   `--LITERAL_NULL -> null [14:15]
+    |       |   `--SEMI -> ; [14:19]
+    |       `--RCURLY -> } [15:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [17:4]
+    |   |--MODIFIERS -> MODIFIERS [17:4]
+    |   |--TYPE -> TYPE [17:4]
+    |   |   |--IDENT -> TypeVariable [17:4]
+    |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [17:16]
+    |   |   |   |--GENERIC_START -> < [17:16]
+    |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [17:17]
+    |   |   |   |   |--IDENT -> Class [17:17]
+    |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [17:22]
+    |   |   |   |       |--GENERIC_START -> < [17:22]
+    |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [17:23]
+    |   |   |   |       |   `--IDENT -> String [17:23]
+    |   |   |   |       `--GENERIC_END -> > [17:29]
+    |   |   |   `--GENERIC_END -> > [17:30]
+    |   |   `--ARRAY_DECLARATOR -> [ [17:31]
+    |   |       `--RBRACK -> ] [17:32]
+    |   |--IDENT -> tester2 [17:34]
+    |   `--SEMI -> ; [17:41]
+    |--METHOD_DEF -> METHOD_DEF [19:4]
+    |   |--MODIFIERS -> MODIFIERS [19:4]
+    |   |   `--LITERAL_PUBLIC -> public [19:4]
+    |   |--TYPE -> TYPE [19:11]
+    |   |   |--IDENT -> TypeVariable [19:11]
+    |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [19:23]
+    |   |   |   |--GENERIC_START -> < [19:23]
+    |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [19:24]
+    |   |   |   |   `--IDENT -> Class [19:24]
+    |   |   |   `--GENERIC_END -> > [19:29]
+    |   |   `--ARRAY_DECLARATOR -> [ [19:30]
+    |   |       `--RBRACK -> ] [19:31]
+    |   |--IDENT -> getTypeParameters1 [19:33]
+    |   |--LPAREN -> ( [19:51]
+    |   |--PARAMETERS -> PARAMETERS [19:52]
+    |   |--RPAREN -> ) [19:52]
+    |   `--SLIST -> { [19:54]
+    |       |--LITERAL_RETURN -> return [20:8]
+    |       |   |--EXPR -> EXPR [20:15]
+    |       |   |   `--LITERAL_NULL -> null [20:15]
+    |       |   `--SEMI -> ; [20:19]
+    |       `--RCURLY -> } [21:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [23:4]
+    |   |--MODIFIERS -> MODIFIERS [23:4]
+    |   |--TYPE -> TYPE [23:4]
+    |   |   |--IDENT -> TypeVariable [23:4]
+    |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [23:16]
+    |   |   |   |--GENERIC_START -> < [23:16]
+    |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [23:17]
+    |   |   |   |   `--IDENT -> Class [23:17]
+    |   |   |   `--GENERIC_END -> > [23:22]
+    |   |   `--ARRAY_DECLARATOR -> [ [23:23]
+    |   |       `--RBRACK -> ] [23:24]
+    |   |--IDENT -> tester1 [23:26]
+    |   `--SEMI -> ; [23:33]
+    `--RCURLY -> } [24:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon.txt
@@ -0,0 +1,1469 @@
+SINGLE_LINE_COMMENT -> // [1:0]
+`--COMMENT_CONTENT -> non-compiled with javac: Compilable with Java16\n [1:2]
+PACKAGE_DEF -> package [2:0]
+|--ANNOTATIONS -> ANNOTATIONS [2:47]
+|--DOT -> . [2:47]
+|   |--DOT -> . [2:39]
+|   |   |--DOT -> . [2:28]
+|   |   |   |--DOT -> . [2:22]
+|   |   |   |   |--DOT -> . [2:11]
+|   |   |   |   |   |--IDENT -> com [2:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [2:12]
+|   |   |   |   `--IDENT -> tools [2:23]
+|   |   |   `--IDENT -> checkstyle [2:29]
+|   |   `--IDENT -> grammar [2:40]
+|   `--IDENT -> antlr4 [2:48]
+`--SEMI -> ; [2:54]
+IMPORT -> import [4:0]
+|--DOT -> . [4:14]
+|   |--DOT -> . [4:11]
+|   |   |--IDENT -> java [4:7]
+|   |   `--IDENT -> io [4:12]
+|   `--IDENT -> Serializable [4:15]
+`--SEMI -> ; [4:27]
+IMPORT -> import [5:0]
+|--DOT -> . [5:16]
+|   |--DOT -> . [5:11]
+|   |   |--IDENT -> java [5:7]
+|   |   `--IDENT -> util [5:12]
+|   `--IDENT -> Collection [5:17]
+`--SEMI -> ; [5:27]
+IMPORT -> import [6:0]
+|--DOT -> . [6:16]
+|   |--DOT -> . [6:11]
+|   |   |--IDENT -> java [6:7]
+|   |   `--IDENT -> util [6:12]
+|   `--IDENT -> Collections [6:17]
+`--SEMI -> ; [6:28]
+IMPORT -> import [7:0]
+|--DOT -> . [7:16]
+|   |--DOT -> . [7:11]
+|   |   |--IDENT -> java [7:7]
+|   |   `--IDENT -> util [7:12]
+|   `--IDENT -> Iterator [7:17]
+`--SEMI -> ; [7:25]
+IMPORT -> import [8:0]
+|--DOT -> . [8:16]
+|   |--DOT -> . [8:11]
+|   |   |--IDENT -> java [8:7]
+|   |   `--IDENT -> util [8:12]
+|   `--IDENT -> List [8:17]
+`--SEMI -> ; [8:21]
+IMPORT -> import [9:0]
+|--DOT -> . [9:16]
+|   |--DOT -> . [9:11]
+|   |   |--IDENT -> java [9:7]
+|   |   `--IDENT -> util [9:12]
+|   `--IDENT -> ListIterator [9:17]
+`--SEMI -> ; [9:29]
+IMPORT -> import [10:0]
+|--DOT -> . [10:25]
+|   |--DOT -> . [10:16]
+|   |   |--DOT -> . [10:11]
+|   |   |   |--IDENT -> java [10:7]
+|   |   |   `--IDENT -> util [10:12]
+|   |   `--IDENT -> function [10:17]
+|   `--IDENT -> IntFunction [10:26]
+`--SEMI -> ; [10:37]
+IMPORT -> import [12:0]
+|--DOT -> . [12:26]
+|   |--DOT -> . [12:20]
+|   |   |--DOT -> . [12:14]
+|   |   |   |--DOT -> . [12:10]
+|   |   |   |   |--IDENT -> com [12:7]
+|   |   |   |   `--IDENT -> sun [12:11]
+|   |   |   `--IDENT -> tools [12:15]
+|   |   `--IDENT -> javac [12:21]
+|   `--IDENT -> Main [12:27]
+`--SEMI -> ; [12:31]
+CLASS_DEF -> CLASS_DEF [14:0]
+|--MODIFIERS -> MODIFIERS [14:0]
+|   `--LITERAL_PUBLIC -> public [14:0]
+|--LITERAL_CLASS -> class [14:7]
+|--IDENT -> InputAntlr4AstRegressionUncommon [14:13]
+|--IMPLEMENTS_CLAUSE -> implements [15:8]
+|   `--IDENT -> MyInterface [15:19]
+`--OBJBLOCK -> OBJBLOCK [15:31]
+    |--LCURLY -> { [15:31]
+    |--VARIABLE_DEF -> VARIABLE_DEF [16:4]
+    |   |--MODIFIERS -> MODIFIERS [16:4]
+    |   |--TYPE -> TYPE [16:4]
+    |   |   |--LITERAL_INT -> int [16:4]
+    |   |   `--ARRAY_DECLARATOR -> [ [16:9]
+    |   |       `--RBRACK -> ] [16:10]
+    |   |--IDENT -> x [16:8]
+    |   `--SEMI -> ; [16:23]
+    |--COMMA -> , [16:11]
+    |--VARIABLE_DEF -> VARIABLE_DEF [16:4]
+    |   |--MODIFIERS -> MODIFIERS [16:4]
+    |   |--TYPE -> TYPE [16:4]
+    |   |   |--LITERAL_INT -> int [16:4]
+    |   |   `--ARRAY_DECLARATOR -> [ [16:14]
+    |   |       `--RBRACK -> ] [16:15]
+    |   `--IDENT -> y [16:13]
+    |--COMMA -> , [16:16]
+    |--VARIABLE_DEF -> VARIABLE_DEF [16:4]
+    |   |--MODIFIERS -> MODIFIERS [16:4]
+    |   |--TYPE -> TYPE [16:4]
+    |   |   |--LITERAL_INT -> int [16:4]
+    |   |   |--ARRAY_DECLARATOR -> [ [16:19]
+    |   |   |   `--RBRACK -> ] [16:20]
+    |   |   `--ARRAY_DECLARATOR -> [ [16:21]
+    |   |       `--RBRACK -> ] [16:22]
+    |   `--IDENT -> z [16:18]
+    |--METHOD_DEF -> METHOD_DEF [18:4]
+    |   |--MODIFIERS -> MODIFIERS [18:4]
+    |   |   `--LITERAL_PUBLIC -> public [18:4]
+    |   |--TYPE -> TYPE [18:11]
+    |   |   |--IDENT -> Double [18:11]
+    |   |   `--ARRAY_DECLARATOR -> [ [18:27]
+    |   |       `--RBRACK -> ] [18:28]
+    |   |--IDENT -> method1 [18:18]
+    |   |--LPAREN -> ( [18:25]
+    |   |--PARAMETERS -> PARAMETERS [18:26]
+    |   |--RPAREN -> ) [18:26]
+    |   `--SLIST -> { [18:30]
+    |       |--LITERAL_RETURN -> return [19:8]
+    |       |   |--EXPR -> EXPR [19:15]
+    |       |   |   `--LITERAL_NULL -> null [19:15]
+    |       |   `--SEMI -> ; [19:19]
+    |       `--RCURLY -> } [20:4]
+    |--METHOD_DEF -> METHOD_DEF [22:4]
+    |   |--MODIFIERS -> MODIFIERS [22:4]
+    |   |   `--LITERAL_PROTECTED -> protected [22:4]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [22:14]
+    |   |   |--GENERIC_START -> < [22:14]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [22:15]
+    |   |   |   `--IDENT -> B [22:15]
+    |   |   |--COMMA -> , [22:16]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [22:18]
+    |   |   |   `--IDENT -> Z [22:18]
+    |   |   |--COMMA -> , [22:19]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [22:21]
+    |   |   |   `--IDENT -> A [22:21]
+    |   |   `--GENERIC_END -> > [22:22]
+    |   |--TYPE -> TYPE [22:34]
+    |   |   `--DOT -> . [22:34]
+    |   |       |--IDENT -> OtherClass [22:24]
+    |   |       |--IDENT -> Q [22:35]
+    |   |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [22:36]
+    |   |           |--GENERIC_START -> < [22:36]
+    |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [22:37]
+    |   |           |   `--IDENT -> A [22:37]
+    |   |           |--COMMA -> , [22:38]
+    |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [22:39]
+    |   |           |   `--IDENT -> B [22:39]
+    |   |           |--COMMA -> , [22:40]
+    |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [22:41]
+    |   |           |   `--IDENT -> Z [22:41]
+    |   |           `--GENERIC_END -> > [22:42]
+    |   |--IDENT -> m [22:44]
+    |   |--LPAREN -> ( [22:45]
+    |   |--PARAMETERS -> PARAMETERS [22:46]
+    |   |--RPAREN -> ) [22:46]
+    |   `--SLIST -> { [22:48]
+    |       |--LITERAL_RETURN -> return [23:8]
+    |       |   |--EXPR -> EXPR [23:15]
+    |       |   |   `--LITERAL_NULL -> null [23:15]
+    |       |   `--SEMI -> ; [23:19]
+    |       `--RCURLY -> } [24:4]
+    `--RCURLY -> } [25:0]
+INTERFACE_DEF -> INTERFACE_DEF [27:0]
+|--MODIFIERS -> MODIFIERS [27:0]
+|--LITERAL_INTERFACE -> interface [27:0]
+|--IDENT -> MyInterface [27:10]
+`--OBJBLOCK -> OBJBLOCK [27:22]
+    |--LCURLY -> { [27:22]
+    |--METHOD_DEF -> METHOD_DEF [28:4]
+    |   |--MODIFIERS -> MODIFIERS [28:4]
+    |   |--TYPE -> TYPE [28:4]
+    |   |   |--IDENT -> Double [28:4]
+    |   |   `--ARRAY_DECLARATOR -> [ [28:20]
+    |   |       `--RBRACK -> ] [28:21]
+    |   |--IDENT -> method1 [28:11]
+    |   |--LPAREN -> ( [28:18]
+    |   |--PARAMETERS -> PARAMETERS [28:19]
+    |   |--RPAREN -> ) [28:19]
+    |   `--SEMI -> ; [28:22]
+    `--RCURLY -> } [29:0]
+CLASS_DEF -> CLASS_DEF [31:0]
+|--MODIFIERS -> MODIFIERS [31:0]
+|--LITERAL_CLASS -> class [31:0]
+|--IDENT -> OtherClass [31:6]
+|--EXTENDS_CLAUSE -> extends [31:17]
+|   `--IDENT -> InputAntlr4AstRegressionUncommon [31:25]
+`--OBJBLOCK -> OBJBLOCK [31:58]
+    |--LCURLY -> { [31:58]
+    |--CTOR_DEF -> CTOR_DEF [32:4]
+    |   |--MODIFIERS -> MODIFIERS [32:4]
+    |   |--IDENT -> OtherClass [32:4]
+    |   |--LPAREN -> ( [32:15]
+    |   |--PARAMETERS -> PARAMETERS [32:16]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [32:16]
+    |   |       |--MODIFIERS -> MODIFIERS [32:16]
+    |   |       |--TYPE -> TYPE [32:16]
+    |   |       |   `--LITERAL_INT -> int [32:16]
+    |   |       `--IDENT -> z [32:20]
+    |   |--RPAREN -> ) [32:21]
+    |   `--SLIST -> { [32:22]
+    |       |--SUPER_CTOR_CALL -> super [33:8]
+    |       |   |--LPAREN -> ( [33:13]
+    |       |   |--ELIST -> ELIST [33:14]
+    |       |   |--RPAREN -> ) [33:14]
+    |       |   `--SEMI -> ; [33:15]
+    |       `--RCURLY -> } [34:4]
+    |--CLASS_DEF -> CLASS_DEF [35:4]
+    |   |--MODIFIERS -> MODIFIERS [35:4]
+    |   |--LITERAL_CLASS -> class [35:4]
+    |   |--IDENT -> Q [35:10]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [35:11]
+    |   |   |--GENERIC_START -> < [35:11]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [35:12]
+    |   |   |   `--IDENT -> A [35:12]
+    |   |   |--COMMA -> , [35:13]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [35:15]
+    |   |   |   `--IDENT -> B [35:15]
+    |   |   |--COMMA -> , [35:16]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [35:18]
+    |   |   |   `--IDENT -> Z [35:18]
+    |   |   `--GENERIC_END -> > [35:19]
+    |   `--OBJBLOCK -> OBJBLOCK [35:20]
+    |       |--LCURLY -> { [35:20]
+    |       `--RCURLY -> } [35:21]
+    |--SEMI -> ; [37:4]
+    |--METHOD_DEF -> METHOD_DEF [38:4]
+    |   |--MODIFIERS -> MODIFIERS [38:4]
+    |   |   `--LITERAL_PUBLIC -> public [38:4]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [38:11]
+    |   |   |--GENERIC_START -> < [38:11]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [38:12]
+    |   |   |   `--IDENT -> Z [38:12]
+    |   |   |--COMMA -> , [38:13]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [38:15]
+    |   |   |   `--IDENT -> B [38:15]
+    |   |   |--COMMA -> , [38:16]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [38:18]
+    |   |   |   `--IDENT -> A [38:18]
+    |   |   `--GENERIC_END -> > [38:19]
+    |   |--TYPE -> TYPE [38:21]
+    |   |   |--IDENT -> Q [38:21]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [38:22]
+    |   |       |--GENERIC_START -> < [38:22]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [38:23]
+    |   |       |   `--IDENT -> A [38:23]
+    |   |       |--COMMA -> , [38:24]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [38:26]
+    |   |       |   `--IDENT -> Z [38:26]
+    |   |       |--COMMA -> , [38:27]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [38:29]
+    |   |       |   `--IDENT -> B [38:29]
+    |   |       `--GENERIC_END -> > [38:30]
+    |   |--IDENT -> m [38:32]
+    |   |--LPAREN -> ( [38:33]
+    |   |--PARAMETERS -> PARAMETERS [38:34]
+    |   |--RPAREN -> ) [38:34]
+    |   `--SLIST -> { [38:36]
+    |       |--LITERAL_RETURN -> return [38:38]
+    |       |   |--EXPR -> EXPR [38:45]
+    |       |   |   `--LITERAL_NULL -> null [38:45]
+    |       |   `--SEMI -> ; [38:49]
+    |       `--RCURLY -> } [38:50]
+    |--CTOR_DEF -> CTOR_DEF [40:4]
+    |   |--MODIFIERS -> MODIFIERS [40:4]
+    |   |--IDENT -> OtherClass [40:4]
+    |   |--LPAREN -> ( [40:15]
+    |   |--PARAMETERS -> PARAMETERS [40:16]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [40:16]
+    |   |   |   |--MODIFIERS -> MODIFIERS [40:16]
+    |   |   |   |--TYPE -> TYPE [40:16]
+    |   |   |   |   `--LITERAL_INT -> int [40:16]
+    |   |   |   `--IDENT -> z [40:20]
+    |   |   |--COMMA -> , [40:21]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [40:23]
+    |   |       |--MODIFIERS -> MODIFIERS [40:23]
+    |   |       |--TYPE -> TYPE [40:23]
+    |   |       |   `--IDENT -> String [40:23]
+    |   |       `--IDENT -> s [40:30]
+    |   |--RPAREN -> ) [40:31]
+    |   `--SLIST -> { [40:32]
+    |       |--EXPR -> EXPR [41:8]
+    |       |   `--LITERAL_NEW -> new [41:8]
+    |       |       |--IDENT -> OtherClass [41:12]
+    |       |       |--LPAREN -> ( [41:22]
+    |       |       |--ELIST -> ELIST [41:23]
+    |       |       |   `--EXPR -> EXPR [41:23]
+    |       |       |       `--NUM_INT -> 2 [41:23]
+    |       |       `--RPAREN -> ) [41:24]
+    |       |--SEMI -> ; [41:25]
+    |       `--RCURLY -> } [42:4]
+    |--CLASS_DEF -> CLASS_DEF [44:4]
+    |   |--MODIFIERS -> MODIFIERS [44:4]
+    |   |--LITERAL_CLASS -> class [44:4]
+    |   |--IDENT -> Inner [44:10]
+    |   `--OBJBLOCK -> OBJBLOCK [44:16]
+    |       |--LCURLY -> { [44:16]
+    |       |--CTOR_DEF -> CTOR_DEF [45:8]
+    |       |   |--MODIFIERS -> MODIFIERS [45:8]
+    |       |   |--IDENT -> Inner [45:8]
+    |       |   |--LPAREN -> ( [45:13]
+    |       |   |--PARAMETERS -> PARAMETERS [45:14]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [45:14]
+    |       |   |       |--MODIFIERS -> MODIFIERS [45:14]
+    |       |   |       |--TYPE -> TYPE [45:14]
+    |       |   |       |   `--LITERAL_INT -> int [45:14]
+    |       |   |       `--IDENT -> x [45:18]
+    |       |   |--RPAREN -> ) [45:19]
+    |       |   `--SLIST -> { [45:21]
+    |       |       `--RCURLY -> } [45:22]
+    |       |--CTOR_DEF -> CTOR_DEF [46:8]
+    |       |   |--MODIFIERS -> MODIFIERS [46:8]
+    |       |   |--IDENT -> Inner [46:8]
+    |       |   |--LPAREN -> ( [46:13]
+    |       |   |--PARAMETERS -> PARAMETERS [46:14]
+    |       |   |--RPAREN -> ) [46:14]
+    |       |   `--SLIST -> { [46:16]
+    |       |       |--CTOR_CALL -> this [47:12]
+    |       |       |   |--LPAREN -> ( [47:16]
+    |       |       |   |--ELIST -> ELIST [47:17]
+    |       |       |   |   `--EXPR -> EXPR [47:17]
+    |       |       |   |       `--NUM_INT -> 2 [47:17]
+    |       |       |   |--RPAREN -> ) [47:18]
+    |       |       |   `--SEMI -> ; [47:19]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [48:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [48:12]
+    |       |       |   |--TYPE -> TYPE [48:12]
+    |       |       |   |   |--IDENT -> List [48:12]
+    |       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [48:16]
+    |       |       |   |       |--GENERIC_START -> < [48:16]
+    |       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [48:17]
+    |       |       |   |       |   `--IDENT -> String [48:17]
+    |       |       |   |       `--GENERIC_END -> > [48:23]
+    |       |       |   |--IDENT -> list [48:25]
+    |       |       |   `--ASSIGN -> = [48:30]
+    |       |       |       `--EXPR -> EXPR [48:32]
+    |       |       |           `--LITERAL_NEW -> new [48:32]
+    |       |       |               |--IDENT -> List [48:36]
+    |       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [48:40]
+    |       |       |               |   |--GENERIC_START -> < [48:40]
+    |       |       |               |   `--GENERIC_END -> > [48:41]
+    |       |       |               |--LPAREN -> ( [48:42]
+    |       |       |               |--ELIST -> ELIST [48:43]
+    |       |       |               |--RPAREN -> ) [48:43]
+    |       |       |               `--OBJBLOCK -> OBJBLOCK [48:45]
+    |       |       |                   |--LCURLY -> { [48:45]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [49:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [49:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [49:16]
+    |       |       |                   |   |   |   |--AT -> @ [49:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [49:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [50:16]
+    |       |       |                   |   |--TYPE -> TYPE [50:23]
+    |       |       |                   |   |   `--LITERAL_INT -> int [50:23]
+    |       |       |                   |   |--IDENT -> size [50:27]
+    |       |       |                   |   |--LPAREN -> ( [50:31]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [50:32]
+    |       |       |                   |   |--RPAREN -> ) [50:32]
+    |       |       |                   |   `--SLIST -> { [50:34]
+    |       |       |                   |       |--LITERAL_RETURN -> return [51:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [51:27]
+    |       |       |                   |       |   |   `--NUM_INT -> 0 [51:27]
+    |       |       |                   |       |   `--SEMI -> ; [51:28]
+    |       |       |                   |       `--RCURLY -> } [52:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [54:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [54:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [54:16]
+    |       |       |                   |   |   |   |--AT -> @ [54:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [54:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [55:16]
+    |       |       |                   |   |--TYPE -> TYPE [55:23]
+    |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [55:23]
+    |       |       |                   |   |--IDENT -> isEmpty [55:31]
+    |       |       |                   |   |--LPAREN -> ( [55:38]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [55:39]
+    |       |       |                   |   |--RPAREN -> ) [55:39]
+    |       |       |                   |   `--SLIST -> { [55:41]
+    |       |       |                   |       |--LITERAL_RETURN -> return [56:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [56:27]
+    |       |       |                   |       |   |   `--LITERAL_FALSE -> false [56:27]
+    |       |       |                   |       |   `--SEMI -> ; [56:32]
+    |       |       |                   |       `--RCURLY -> } [57:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [59:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [59:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [59:16]
+    |       |       |                   |   |   |   |--AT -> @ [59:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [59:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [60:16]
+    |       |       |                   |   |--TYPE -> TYPE [60:23]
+    |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [60:23]
+    |       |       |                   |   |--IDENT -> contains [60:31]
+    |       |       |                   |   |--LPAREN -> ( [60:39]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [60:40]
+    |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [60:40]
+    |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [60:40]
+    |       |       |                   |   |       |--TYPE -> TYPE [60:40]
+    |       |       |                   |   |       |   `--IDENT -> Object [60:40]
+    |       |       |                   |   |       `--IDENT -> o [60:47]
+    |       |       |                   |   |--RPAREN -> ) [60:48]
+    |       |       |                   |   `--SLIST -> { [60:50]
+    |       |       |                   |       |--LITERAL_RETURN -> return [61:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [61:27]
+    |       |       |                   |       |   |   `--LITERAL_FALSE -> false [61:27]
+    |       |       |                   |       |   `--SEMI -> ; [61:32]
+    |       |       |                   |       `--RCURLY -> } [62:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [64:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [64:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [64:16]
+    |       |       |                   |   |   |   |--AT -> @ [64:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [64:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [65:16]
+    |       |       |                   |   |--TYPE -> TYPE [65:23]
+    |       |       |                   |   |   |--IDENT -> Iterator [65:23]
+    |       |       |                   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [65:31]
+    |       |       |                   |   |       |--GENERIC_START -> < [65:31]
+    |       |       |                   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [65:32]
+    |       |       |                   |   |       |   `--IDENT -> String [65:32]
+    |       |       |                   |   |       `--GENERIC_END -> > [65:38]
+    |       |       |                   |   |--IDENT -> iterator [65:40]
+    |       |       |                   |   |--LPAREN -> ( [65:48]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [65:49]
+    |       |       |                   |   |--RPAREN -> ) [65:49]
+    |       |       |                   |   `--SLIST -> { [65:51]
+    |       |       |                   |       |--LITERAL_RETURN -> return [66:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [66:27]
+    |       |       |                   |       |   |   `--LITERAL_NULL -> null [66:27]
+    |       |       |                   |       |   `--SEMI -> ; [66:31]
+    |       |       |                   |       `--RCURLY -> } [67:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [69:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [69:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [69:16]
+    |       |       |                   |   |   |   |--AT -> @ [69:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [69:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [70:16]
+    |       |       |                   |   |--TYPE -> TYPE [70:23]
+    |       |       |                   |   |   |--IDENT -> Object [70:23]
+    |       |       |                   |   |   `--ARRAY_DECLARATOR -> [ [70:29]
+    |       |       |                   |   |       `--RBRACK -> ] [70:30]
+    |       |       |                   |   |--IDENT -> toArray [70:32]
+    |       |       |                   |   |--LPAREN -> ( [70:39]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [70:40]
+    |       |       |                   |   |--RPAREN -> ) [70:40]
+    |       |       |                   |   `--SLIST -> { [70:42]
+    |       |       |                   |       |--LITERAL_RETURN -> return [71:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [71:27]
+    |       |       |                   |       |   |   `--LITERAL_NEW -> new [71:27]
+    |       |       |                   |       |   |       |--IDENT -> Object [71:31]
+    |       |       |                   |       |   |       `--ARRAY_DECLARATOR -> [ [71:37]
+    |       |       |                   |       |   |           |--EXPR -> EXPR [71:38]
+    |       |       |                   |       |   |           |   `--NUM_INT -> 0 [71:38]
+    |       |       |                   |       |   |           `--RBRACK -> ] [71:39]
+    |       |       |                   |       |   `--SEMI -> ; [71:40]
+    |       |       |                   |       `--RCURLY -> } [72:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [74:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [74:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [74:16]
+    |       |       |                   |   |   |   |--AT -> @ [74:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [74:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [75:16]
+    |       |       |                   |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [75:23]
+    |       |       |                   |   |   |--GENERIC_START -> < [75:23]
+    |       |       |                   |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [75:24]
+    |       |       |                   |   |   |   `--IDENT -> T [75:24]
+    |       |       |                   |   |   `--GENERIC_END -> > [75:25]
+    |       |       |                   |   |--TYPE -> TYPE [75:27]
+    |       |       |                   |   |   |--IDENT -> T [75:27]
+    |       |       |                   |   |   `--ARRAY_DECLARATOR -> [ [75:28]
+    |       |       |                   |   |       `--RBRACK -> ] [75:29]
+    |       |       |                   |   |--IDENT -> toArray [75:31]
+    |       |       |                   |   |--LPAREN -> ( [75:38]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [75:39]
+    |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [75:39]
+    |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [75:39]
+    |       |       |                   |   |       |--TYPE -> TYPE [75:39]
+    |       |       |                   |   |       |   |--IDENT -> T [75:39]
+    |       |       |                   |   |       |   `--ARRAY_DECLARATOR -> [ [75:40]
+    |       |       |                   |   |       |       `--RBRACK -> ] [75:41]
+    |       |       |                   |   |       `--IDENT -> a [75:43]
+    |       |       |                   |   |--RPAREN -> ) [75:44]
+    |       |       |                   |   `--SLIST -> { [75:46]
+    |       |       |                   |       |--LITERAL_RETURN -> return [76:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [76:27]
+    |       |       |                   |       |   |   `--LITERAL_NULL -> null [76:27]
+    |       |       |                   |       |   `--SEMI -> ; [76:31]
+    |       |       |                   |       `--RCURLY -> } [77:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [79:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [79:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [79:16]
+    |       |       |                   |   |   |   |--AT -> @ [79:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [79:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [80:16]
+    |       |       |                   |   |--TYPE -> TYPE [80:23]
+    |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [80:23]
+    |       |       |                   |   |--IDENT -> add [80:31]
+    |       |       |                   |   |--LPAREN -> ( [80:34]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [80:35]
+    |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [80:35]
+    |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [80:35]
+    |       |       |                   |   |       |--TYPE -> TYPE [80:35]
+    |       |       |                   |   |       |   `--IDENT -> String [80:35]
+    |       |       |                   |   |       `--IDENT -> s [80:42]
+    |       |       |                   |   |--RPAREN -> ) [80:43]
+    |       |       |                   |   `--SLIST -> { [80:45]
+    |       |       |                   |       |--LITERAL_RETURN -> return [81:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [81:27]
+    |       |       |                   |       |   |   `--LITERAL_FALSE -> false [81:27]
+    |       |       |                   |       |   `--SEMI -> ; [81:32]
+    |       |       |                   |       `--RCURLY -> } [82:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [84:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [84:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [84:16]
+    |       |       |                   |   |   |   |--AT -> @ [84:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [84:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [85:16]
+    |       |       |                   |   |--TYPE -> TYPE [85:23]
+    |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [85:23]
+    |       |       |                   |   |--IDENT -> remove [85:31]
+    |       |       |                   |   |--LPAREN -> ( [85:37]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [85:38]
+    |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [85:38]
+    |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [85:38]
+    |       |       |                   |   |       |--TYPE -> TYPE [85:38]
+    |       |       |                   |   |       |   `--IDENT -> Object [85:38]
+    |       |       |                   |   |       `--IDENT -> o [85:45]
+    |       |       |                   |   |--RPAREN -> ) [85:46]
+    |       |       |                   |   `--SLIST -> { [85:48]
+    |       |       |                   |       |--LITERAL_RETURN -> return [86:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [86:27]
+    |       |       |                   |       |   |   `--LITERAL_FALSE -> false [86:27]
+    |       |       |                   |       |   `--SEMI -> ; [86:32]
+    |       |       |                   |       `--RCURLY -> } [87:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [89:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [89:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [89:16]
+    |       |       |                   |   |   |   |--AT -> @ [89:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [89:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [90:16]
+    |       |       |                   |   |--TYPE -> TYPE [90:23]
+    |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [90:23]
+    |       |       |                   |   |--IDENT -> containsAll [90:31]
+    |       |       |                   |   |--LPAREN -> ( [90:42]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [90:43]
+    |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [90:43]
+    |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [90:43]
+    |       |       |                   |   |       |--TYPE -> TYPE [90:43]
+    |       |       |                   |   |       |   |--IDENT -> Collection [90:43]
+    |       |       |                   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [90:53]
+    |       |       |                   |   |       |       |--GENERIC_START -> < [90:53]
+    |       |       |                   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [90:54]
+    |       |       |                   |   |       |       |   `--WILDCARD_TYPE -> ? [90:54]
+    |       |       |                   |   |       |       `--GENERIC_END -> > [90:55]
+    |       |       |                   |   |       `--IDENT -> c [90:57]
+    |       |       |                   |   |--RPAREN -> ) [90:58]
+    |       |       |                   |   `--SLIST -> { [90:60]
+    |       |       |                   |       |--LITERAL_RETURN -> return [91:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [91:27]
+    |       |       |                   |       |   |   `--LITERAL_FALSE -> false [91:27]
+    |       |       |                   |       |   `--SEMI -> ; [91:32]
+    |       |       |                   |       `--RCURLY -> } [92:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [94:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [94:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [94:16]
+    |       |       |                   |   |   |   |--AT -> @ [94:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [94:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [95:16]
+    |       |       |                   |   |--TYPE -> TYPE [95:23]
+    |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [95:23]
+    |       |       |                   |   |--IDENT -> addAll [95:31]
+    |       |       |                   |   |--LPAREN -> ( [95:37]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [95:38]
+    |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [95:38]
+    |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [95:38]
+    |       |       |                   |   |       |--TYPE -> TYPE [95:38]
+    |       |       |                   |   |       |   |--IDENT -> Collection [95:38]
+    |       |       |                   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [95:48]
+    |       |       |                   |   |       |       |--GENERIC_START -> < [95:48]
+    |       |       |                   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [95:49]
+    |       |       |                   |   |       |       |   |--WILDCARD_TYPE -> ? [95:49]
+    |       |       |                   |   |       |       |   `--TYPE_UPPER_BOUNDS -> extends [95:51]
+    |       |       |                   |   |       |       |       `--IDENT -> String [95:59]
+    |       |       |                   |   |       |       `--GENERIC_END -> > [95:65]
+    |       |       |                   |   |       `--IDENT -> c [95:67]
+    |       |       |                   |   |--RPAREN -> ) [95:68]
+    |       |       |                   |   `--SLIST -> { [95:70]
+    |       |       |                   |       |--LITERAL_RETURN -> return [96:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [96:27]
+    |       |       |                   |       |   |   `--LITERAL_FALSE -> false [96:27]
+    |       |       |                   |       |   `--SEMI -> ; [96:32]
+    |       |       |                   |       `--RCURLY -> } [97:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [99:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [99:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [99:16]
+    |       |       |                   |   |   |   |--AT -> @ [99:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [99:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [100:16]
+    |       |       |                   |   |--TYPE -> TYPE [100:23]
+    |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [100:23]
+    |       |       |                   |   |--IDENT -> addAll [100:31]
+    |       |       |                   |   |--LPAREN -> ( [100:37]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [100:38]
+    |       |       |                   |   |   |--PARAMETER_DEF -> PARAMETER_DEF [100:38]
+    |       |       |                   |   |   |   |--MODIFIERS -> MODIFIERS [100:38]
+    |       |       |                   |   |   |   |--TYPE -> TYPE [100:38]
+    |       |       |                   |   |   |   |   `--LITERAL_INT -> int [100:38]
+    |       |       |                   |   |   |   `--IDENT -> index [100:42]
+    |       |       |                   |   |   |--COMMA -> , [100:47]
+    |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [100:49]
+    |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [100:49]
+    |       |       |                   |   |       |--TYPE -> TYPE [100:49]
+    |       |       |                   |   |       |   |--IDENT -> Collection [100:49]
+    |       |       |                   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [100:59]
+    |       |       |                   |   |       |       |--GENERIC_START -> < [100:59]
+    |       |       |                   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [100:60]
+    |       |       |                   |   |       |       |   |--WILDCARD_TYPE -> ? [100:60]
+    |       |       |                   |   |       |       |   `--TYPE_UPPER_BOUNDS -> extends [100:62]
+    |       |       |                   |   |       |       |       `--IDENT -> String [100:70]
+    |       |       |                   |   |       |       `--GENERIC_END -> > [100:76]
+    |       |       |                   |   |       `--IDENT -> c [100:78]
+    |       |       |                   |   |--RPAREN -> ) [100:79]
+    |       |       |                   |   `--SLIST -> { [100:81]
+    |       |       |                   |       |--LITERAL_RETURN -> return [101:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [101:27]
+    |       |       |                   |       |   |   `--LITERAL_FALSE -> false [101:27]
+    |       |       |                   |       |   `--SEMI -> ; [101:32]
+    |       |       |                   |       `--RCURLY -> } [102:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [104:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [104:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [104:16]
+    |       |       |                   |   |   |   |--AT -> @ [104:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [104:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [105:16]
+    |       |       |                   |   |--TYPE -> TYPE [105:23]
+    |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [105:23]
+    |       |       |                   |   |--IDENT -> removeAll [105:31]
+    |       |       |                   |   |--LPAREN -> ( [105:40]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [105:41]
+    |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [105:41]
+    |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [105:41]
+    |       |       |                   |   |       |--TYPE -> TYPE [105:41]
+    |       |       |                   |   |       |   |--IDENT -> Collection [105:41]
+    |       |       |                   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [105:51]
+    |       |       |                   |   |       |       |--GENERIC_START -> < [105:51]
+    |       |       |                   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [105:52]
+    |       |       |                   |   |       |       |   `--WILDCARD_TYPE -> ? [105:52]
+    |       |       |                   |   |       |       `--GENERIC_END -> > [105:53]
+    |       |       |                   |   |       `--IDENT -> c [105:55]
+    |       |       |                   |   |--RPAREN -> ) [105:56]
+    |       |       |                   |   `--SLIST -> { [105:58]
+    |       |       |                   |       |--LITERAL_RETURN -> return [106:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [106:27]
+    |       |       |                   |       |   |   `--LITERAL_FALSE -> false [106:27]
+    |       |       |                   |       |   `--SEMI -> ; [106:32]
+    |       |       |                   |       `--RCURLY -> } [107:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [109:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [109:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [109:16]
+    |       |       |                   |   |   |   |--AT -> @ [109:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [109:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [110:16]
+    |       |       |                   |   |--TYPE -> TYPE [110:23]
+    |       |       |                   |   |   `--LITERAL_BOOLEAN -> boolean [110:23]
+    |       |       |                   |   |--IDENT -> retainAll [110:31]
+    |       |       |                   |   |--LPAREN -> ( [110:40]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [110:41]
+    |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [110:41]
+    |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [110:41]
+    |       |       |                   |   |       |--TYPE -> TYPE [110:41]
+    |       |       |                   |   |       |   |--IDENT -> Collection [110:41]
+    |       |       |                   |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [110:51]
+    |       |       |                   |   |       |       |--GENERIC_START -> < [110:51]
+    |       |       |                   |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [110:52]
+    |       |       |                   |   |       |       |   `--WILDCARD_TYPE -> ? [110:52]
+    |       |       |                   |   |       |       `--GENERIC_END -> > [110:53]
+    |       |       |                   |   |       `--IDENT -> c [110:55]
+    |       |       |                   |   |--RPAREN -> ) [110:56]
+    |       |       |                   |   `--SLIST -> { [110:58]
+    |       |       |                   |       |--LITERAL_RETURN -> return [111:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [111:27]
+    |       |       |                   |       |   |   `--LITERAL_FALSE -> false [111:27]
+    |       |       |                   |       |   `--SEMI -> ; [111:32]
+    |       |       |                   |       `--RCURLY -> } [112:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [114:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [114:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [114:16]
+    |       |       |                   |   |   |   |--AT -> @ [114:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [114:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [115:16]
+    |       |       |                   |   |--TYPE -> TYPE [115:23]
+    |       |       |                   |   |   `--LITERAL_VOID -> void [115:23]
+    |       |       |                   |   |--IDENT -> clear [115:28]
+    |       |       |                   |   |--LPAREN -> ( [115:33]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [115:34]
+    |       |       |                   |   |--RPAREN -> ) [115:34]
+    |       |       |                   |   `--SLIST -> { [115:36]
+    |       |       |                   |       `--RCURLY -> } [117:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [119:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [119:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [119:16]
+    |       |       |                   |   |   |   |--AT -> @ [119:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [119:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [120:16]
+    |       |       |                   |   |--TYPE -> TYPE [120:23]
+    |       |       |                   |   |   `--IDENT -> String [120:23]
+    |       |       |                   |   |--IDENT -> get [120:30]
+    |       |       |                   |   |--LPAREN -> ( [120:33]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [120:34]
+    |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [120:34]
+    |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [120:34]
+    |       |       |                   |   |       |--TYPE -> TYPE [120:34]
+    |       |       |                   |   |       |   `--LITERAL_INT -> int [120:34]
+    |       |       |                   |   |       `--IDENT -> index [120:38]
+    |       |       |                   |   |--RPAREN -> ) [120:43]
+    |       |       |                   |   `--SLIST -> { [120:45]
+    |       |       |                   |       |--LITERAL_RETURN -> return [121:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [121:27]
+    |       |       |                   |       |   |   `--LITERAL_NULL -> null [121:27]
+    |       |       |                   |       |   `--SEMI -> ; [121:31]
+    |       |       |                   |       `--RCURLY -> } [122:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [124:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [124:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [124:16]
+    |       |       |                   |   |   |   |--AT -> @ [124:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [124:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [125:16]
+    |       |       |                   |   |--TYPE -> TYPE [125:23]
+    |       |       |                   |   |   `--IDENT -> String [125:23]
+    |       |       |                   |   |--IDENT -> set [125:30]
+    |       |       |                   |   |--LPAREN -> ( [125:33]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [125:34]
+    |       |       |                   |   |   |--PARAMETER_DEF -> PARAMETER_DEF [125:34]
+    |       |       |                   |   |   |   |--MODIFIERS -> MODIFIERS [125:34]
+    |       |       |                   |   |   |   |--TYPE -> TYPE [125:34]
+    |       |       |                   |   |   |   |   `--LITERAL_INT -> int [125:34]
+    |       |       |                   |   |   |   `--IDENT -> index [125:38]
+    |       |       |                   |   |   |--COMMA -> , [125:43]
+    |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [125:45]
+    |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [125:45]
+    |       |       |                   |   |       |--TYPE -> TYPE [125:45]
+    |       |       |                   |   |       |   `--IDENT -> String [125:45]
+    |       |       |                   |   |       `--IDENT -> element [125:52]
+    |       |       |                   |   |--RPAREN -> ) [125:59]
+    |       |       |                   |   `--SLIST -> { [125:61]
+    |       |       |                   |       |--LITERAL_RETURN -> return [126:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [126:27]
+    |       |       |                   |       |   |   `--LITERAL_NULL -> null [126:27]
+    |       |       |                   |       |   `--SEMI -> ; [126:31]
+    |       |       |                   |       `--RCURLY -> } [127:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [129:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [129:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [129:16]
+    |       |       |                   |   |   |   |--AT -> @ [129:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [129:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [130:16]
+    |       |       |                   |   |--TYPE -> TYPE [130:23]
+    |       |       |                   |   |   `--LITERAL_VOID -> void [130:23]
+    |       |       |                   |   |--IDENT -> add [130:28]
+    |       |       |                   |   |--LPAREN -> ( [130:31]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [130:32]
+    |       |       |                   |   |   |--PARAMETER_DEF -> PARAMETER_DEF [130:32]
+    |       |       |                   |   |   |   |--MODIFIERS -> MODIFIERS [130:32]
+    |       |       |                   |   |   |   |--TYPE -> TYPE [130:32]
+    |       |       |                   |   |   |   |   `--LITERAL_INT -> int [130:32]
+    |       |       |                   |   |   |   `--IDENT -> index [130:36]
+    |       |       |                   |   |   |--COMMA -> , [130:41]
+    |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [130:43]
+    |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [130:43]
+    |       |       |                   |   |       |--TYPE -> TYPE [130:43]
+    |       |       |                   |   |       |   `--IDENT -> String [130:43]
+    |       |       |                   |   |       `--IDENT -> element [130:50]
+    |       |       |                   |   |--RPAREN -> ) [130:57]
+    |       |       |                   |   `--SLIST -> { [130:59]
+    |       |       |                   |       `--RCURLY -> } [132:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [134:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [134:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [134:16]
+    |       |       |                   |   |   |   |--AT -> @ [134:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [134:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [135:16]
+    |       |       |                   |   |--TYPE -> TYPE [135:23]
+    |       |       |                   |   |   `--IDENT -> String [135:23]
+    |       |       |                   |   |--IDENT -> remove [135:30]
+    |       |       |                   |   |--LPAREN -> ( [135:36]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [135:37]
+    |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [135:37]
+    |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [135:37]
+    |       |       |                   |   |       |--TYPE -> TYPE [135:37]
+    |       |       |                   |   |       |   `--LITERAL_INT -> int [135:37]
+    |       |       |                   |   |       `--IDENT -> index [135:41]
+    |       |       |                   |   |--RPAREN -> ) [135:46]
+    |       |       |                   |   `--SLIST -> { [135:48]
+    |       |       |                   |       |--LITERAL_RETURN -> return [136:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [136:27]
+    |       |       |                   |       |   |   `--LITERAL_NULL -> null [136:27]
+    |       |       |                   |       |   `--SEMI -> ; [136:31]
+    |       |       |                   |       `--RCURLY -> } [137:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [139:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [139:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [139:16]
+    |       |       |                   |   |   |   |--AT -> @ [139:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [139:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [140:16]
+    |       |       |                   |   |--TYPE -> TYPE [140:23]
+    |       |       |                   |   |   `--LITERAL_INT -> int [140:23]
+    |       |       |                   |   |--IDENT -> indexOf [140:27]
+    |       |       |                   |   |--LPAREN -> ( [140:34]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [140:35]
+    |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [140:35]
+    |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [140:35]
+    |       |       |                   |   |       |--TYPE -> TYPE [140:35]
+    |       |       |                   |   |       |   `--IDENT -> Object [140:35]
+    |       |       |                   |   |       `--IDENT -> o [140:42]
+    |       |       |                   |   |--RPAREN -> ) [140:43]
+    |       |       |                   |   `--SLIST -> { [140:45]
+    |       |       |                   |       |--LITERAL_RETURN -> return [141:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [141:27]
+    |       |       |                   |       |   |   `--NUM_INT -> 0 [141:27]
+    |       |       |                   |       |   `--SEMI -> ; [141:28]
+    |       |       |                   |       `--RCURLY -> } [142:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [144:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [144:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [144:16]
+    |       |       |                   |   |   |   |--AT -> @ [144:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [144:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [145:16]
+    |       |       |                   |   |--TYPE -> TYPE [145:23]
+    |       |       |                   |   |   `--LITERAL_INT -> int [145:23]
+    |       |       |                   |   |--IDENT -> lastIndexOf [145:27]
+    |       |       |                   |   |--LPAREN -> ( [145:38]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [145:39]
+    |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [145:39]
+    |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [145:39]
+    |       |       |                   |   |       |--TYPE -> TYPE [145:39]
+    |       |       |                   |   |       |   `--IDENT -> Object [145:39]
+    |       |       |                   |   |       `--IDENT -> o [145:46]
+    |       |       |                   |   |--RPAREN -> ) [145:47]
+    |       |       |                   |   `--SLIST -> { [145:49]
+    |       |       |                   |       |--LITERAL_RETURN -> return [146:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [146:27]
+    |       |       |                   |       |   |   `--NUM_INT -> 0 [146:27]
+    |       |       |                   |       |   `--SEMI -> ; [146:28]
+    |       |       |                   |       `--RCURLY -> } [147:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [149:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [149:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [149:16]
+    |       |       |                   |   |   |   |--AT -> @ [149:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [149:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [150:16]
+    |       |       |                   |   |--TYPE -> TYPE [150:23]
+    |       |       |                   |   |   |--IDENT -> ListIterator [150:23]
+    |       |       |                   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [150:35]
+    |       |       |                   |   |       |--GENERIC_START -> < [150:35]
+    |       |       |                   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [150:36]
+    |       |       |                   |   |       |   `--IDENT -> String [150:36]
+    |       |       |                   |   |       `--GENERIC_END -> > [150:42]
+    |       |       |                   |   |--IDENT -> listIterator [150:44]
+    |       |       |                   |   |--LPAREN -> ( [150:56]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [150:57]
+    |       |       |                   |   |--RPAREN -> ) [150:57]
+    |       |       |                   |   `--SLIST -> { [150:59]
+    |       |       |                   |       |--LITERAL_RETURN -> return [151:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [151:27]
+    |       |       |                   |       |   |   `--LITERAL_NULL -> null [151:27]
+    |       |       |                   |       |   `--SEMI -> ; [151:31]
+    |       |       |                   |       `--RCURLY -> } [152:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [154:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [154:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [154:16]
+    |       |       |                   |   |   |   |--AT -> @ [154:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [154:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [155:16]
+    |       |       |                   |   |--TYPE -> TYPE [155:23]
+    |       |       |                   |   |   |--IDENT -> ListIterator [155:23]
+    |       |       |                   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [155:35]
+    |       |       |                   |   |       |--GENERIC_START -> < [155:35]
+    |       |       |                   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [155:36]
+    |       |       |                   |   |       |   `--IDENT -> String [155:36]
+    |       |       |                   |   |       `--GENERIC_END -> > [155:42]
+    |       |       |                   |   |--IDENT -> listIterator [155:44]
+    |       |       |                   |   |--LPAREN -> ( [155:56]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [155:57]
+    |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [155:57]
+    |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [155:57]
+    |       |       |                   |   |       |--TYPE -> TYPE [155:57]
+    |       |       |                   |   |       |   `--LITERAL_INT -> int [155:57]
+    |       |       |                   |   |       `--IDENT -> index [155:61]
+    |       |       |                   |   |--RPAREN -> ) [155:66]
+    |       |       |                   |   `--SLIST -> { [155:68]
+    |       |       |                   |       |--LITERAL_RETURN -> return [156:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [156:27]
+    |       |       |                   |       |   |   `--LITERAL_NULL -> null [156:27]
+    |       |       |                   |       |   `--SEMI -> ; [156:31]
+    |       |       |                   |       `--RCURLY -> } [157:16]
+    |       |       |                   |--METHOD_DEF -> METHOD_DEF [159:16]
+    |       |       |                   |   |--MODIFIERS -> MODIFIERS [159:16]
+    |       |       |                   |   |   |--ANNOTATION -> ANNOTATION [159:16]
+    |       |       |                   |   |   |   |--AT -> @ [159:16]
+    |       |       |                   |   |   |   `--IDENT -> Override [159:17]
+    |       |       |                   |   |   `--LITERAL_PUBLIC -> public [160:16]
+    |       |       |                   |   |--TYPE -> TYPE [160:23]
+    |       |       |                   |   |   |--IDENT -> List [160:23]
+    |       |       |                   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [160:27]
+    |       |       |                   |   |       |--GENERIC_START -> < [160:27]
+    |       |       |                   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [160:28]
+    |       |       |                   |   |       |   `--IDENT -> String [160:28]
+    |       |       |                   |   |       `--GENERIC_END -> > [160:34]
+    |       |       |                   |   |--IDENT -> subList [160:36]
+    |       |       |                   |   |--LPAREN -> ( [160:43]
+    |       |       |                   |   |--PARAMETERS -> PARAMETERS [160:44]
+    |       |       |                   |   |   |--PARAMETER_DEF -> PARAMETER_DEF [160:44]
+    |       |       |                   |   |   |   |--MODIFIERS -> MODIFIERS [160:44]
+    |       |       |                   |   |   |   |--TYPE -> TYPE [160:44]
+    |       |       |                   |   |   |   |   `--LITERAL_INT -> int [160:44]
+    |       |       |                   |   |   |   `--IDENT -> fromIndex [160:48]
+    |       |       |                   |   |   |--COMMA -> , [160:57]
+    |       |       |                   |   |   `--PARAMETER_DEF -> PARAMETER_DEF [160:59]
+    |       |       |                   |   |       |--MODIFIERS -> MODIFIERS [160:59]
+    |       |       |                   |   |       |--TYPE -> TYPE [160:59]
+    |       |       |                   |   |       |   `--LITERAL_INT -> int [160:59]
+    |       |       |                   |   |       `--IDENT -> toIndex [160:63]
+    |       |       |                   |   |--RPAREN -> ) [160:70]
+    |       |       |                   |   `--SLIST -> { [160:72]
+    |       |       |                   |       |--LITERAL_RETURN -> return [161:20]
+    |       |       |                   |       |   |--EXPR -> EXPR [161:27]
+    |       |       |                   |       |   |   `--LITERAL_NULL -> null [161:27]
+    |       |       |                   |       |   `--SEMI -> ; [161:31]
+    |       |       |                   |       `--RCURLY -> } [162:16]
+    |       |       |                   `--RCURLY -> } [163:12]
+    |       |       |--SEMI -> ; [163:13]
+    |       |       `--RCURLY -> } [164:8]
+    |       `--RCURLY -> } [165:4]
+    |--CLASS_DEF -> CLASS_DEF [167:4]
+    |   |--MODIFIERS -> MODIFIERS [167:4]
+    |   |--LITERAL_CLASS -> class [167:4]
+    |   |--IDENT -> OtherInner [167:10]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [167:20]
+    |   |   |--GENERIC_START -> < [167:20]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [167:21]
+    |   |   |   `--IDENT -> E [167:21]
+    |   |   `--GENERIC_END -> > [167:22]
+    |   `--OBJBLOCK -> OBJBLOCK [167:24]
+    |       |--LCURLY -> { [167:24]
+    |       |--CTOR_DEF -> CTOR_DEF [168:8]
+    |       |   |--MODIFIERS -> MODIFIERS [168:8]
+    |       |   |--IDENT -> OtherInner [168:8]
+    |       |   |--LPAREN -> ( [168:18]
+    |       |   |--PARAMETERS -> PARAMETERS [168:19]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [168:19]
+    |       |   |       |--MODIFIERS -> MODIFIERS [168:19]
+    |       |   |       |--TYPE -> TYPE [168:19]
+    |       |   |       |   `--LITERAL_INT -> int [168:19]
+    |       |   |       `--IDENT -> w [168:23]
+    |       |   |--RPAREN -> ) [168:24]
+    |       |   `--SLIST -> { [168:25]
+    |       |       `--RCURLY -> } [168:26]
+    |       |--CTOR_DEF -> CTOR_DEF [169:8]
+    |       |   |--MODIFIERS -> MODIFIERS [169:8]
+    |       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [169:8]
+    |       |   |   |--GENERIC_START -> < [169:8]
+    |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [169:9]
+    |       |   |   |   |--IDENT -> T [169:9]
+    |       |   |   |   `--TYPE_UPPER_BOUNDS -> extends [169:11]
+    |       |   |   |       `--IDENT -> Serializable [169:19]
+    |       |   |   `--GENERIC_END -> > [169:31]
+    |       |   |--IDENT -> OtherInner [169:33]
+    |       |   |--LPAREN -> ( [169:43]
+    |       |   |--PARAMETERS -> PARAMETERS [169:44]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [169:44]
+    |       |   |       |--MODIFIERS -> MODIFIERS [169:44]
+    |       |   |       |--TYPE -> TYPE [169:44]
+    |       |   |       |   `--IDENT -> T [169:44]
+    |       |   |       `--IDENT -> element [169:46]
+    |       |   |--RPAREN -> ) [169:53]
+    |       |   `--SLIST -> { [169:55]
+    |       |       `--RCURLY -> } [171:8]
+    |       |--CTOR_DEF -> CTOR_DEF [172:8]
+    |       |   |--MODIFIERS -> MODIFIERS [172:8]
+    |       |   |--IDENT -> OtherInner [172:8]
+    |       |   |--LPAREN -> ( [172:18]
+    |       |   |--PARAMETERS -> PARAMETERS [172:19]
+    |       |   |--RPAREN -> ) [172:19]
+    |       |   `--SLIST -> { [172:21]
+    |       |       |--CTOR_CALL -> this [173:15]
+    |       |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [173:12]
+    |       |       |   |   |--GENERIC_START -> < [173:12]
+    |       |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [173:13]
+    |       |       |   |   |   `--IDENT -> E [173:13]
+    |       |       |   |   `--GENERIC_END -> > [173:14]
+    |       |       |   |--LPAREN -> ( [173:19]
+    |       |       |   |--ELIST -> ELIST [173:20]
+    |       |       |   |   `--EXPR -> EXPR [173:20]
+    |       |       |   |       `--NUM_INT -> 2 [173:20]
+    |       |       |   |--RPAREN -> ) [173:21]
+    |       |       |   `--SEMI -> ; [173:22]
+    |       |       `--RCURLY -> } [174:8]
+    |       `--RCURLY -> } [175:4]
+    |--METHOD_DEF -> METHOD_DEF [177:4]
+    |   |--MODIFIERS -> MODIFIERS [177:4]
+    |   |   `--LITERAL_PRIVATE -> private [177:4]
+    |   |--TYPE -> TYPE [177:12]
+    |   |   `--LITERAL_VOID -> void [177:12]
+    |   |--IDENT -> killAll [177:17]
+    |   |--LPAREN -> ( [177:24]
+    |   |--PARAMETERS -> PARAMETERS [177:25]
+    |   |--RPAREN -> ) [177:25]
+    |   `--SLIST -> { [177:27]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [178:10]
+    |       |   |--MODIFIERS -> MODIFIERS [178:10]
+    |       |   |--TYPE -> TYPE [178:10]
+    |       |   |   `--LITERAL_BOOLEAN -> boolean [178:10]
+    |       |   |--IDENT -> oneAlive [178:18]
+    |       |   `--ASSIGN -> = [178:27]
+    |       |       `--EXPR -> EXPR [178:29]
+    |       |           `--LITERAL_FALSE -> false [178:29]
+    |       |--SEMI -> ; [178:34]
+    |       |--LITERAL_IF -> if [179:14]
+    |       |   |--LPAREN -> ( [179:17]
+    |       |   |--EXPR -> EXPR [179:18]
+    |       |   |   `--IDENT -> oneAlive [179:18]
+    |       |   |--RPAREN -> ) [179:26]
+    |       |   `--SLIST -> { [179:28]
+    |       |       |--EXPR -> EXPR [180:30]
+    |       |       |   `--METHOD_CALL -> ( [180:30]
+    |       |       |       |--DOT -> . [180:24]
+    |       |       |       |   |--IDENT -> Thread [180:18]
+    |       |       |       |   `--IDENT -> yield [180:25]
+    |       |       |       |--ELIST -> ELIST [180:31]
+    |       |       |       `--RPAREN -> ) [180:31]
+    |       |       |--SEMI -> ; [180:32]
+    |       |       `--RCURLY -> } [181:14]
+    |       `--RCURLY -> } [183:6]
+    |--CLASS_DEF -> CLASS_DEF [184:4]
+    |   |--MODIFIERS -> MODIFIERS [184:4]
+    |   |--LITERAL_CLASS -> class [184:4]
+    |   |--IDENT -> SuperClassA [184:10]
+    |   `--OBJBLOCK -> OBJBLOCK [184:21]
+    |       |--LCURLY -> { [184:21]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [185:8]
+    |       |   |--MODIFIERS -> MODIFIERS [185:8]
+    |       |   |   `--LITERAL_PROTECTED -> protected [185:8]
+    |       |   |--TYPE -> TYPE [185:18]
+    |       |   |   `--IDENT -> SuperClassA [185:18]
+    |       |   |--IDENT -> bs [185:30]
+    |       |   `--SEMI -> ; [185:32]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [186:8]
+    |       |   |--MODIFIERS -> MODIFIERS [186:8]
+    |       |   |   `--LITERAL_PROTECTED -> protected [186:8]
+    |       |   |--TYPE -> TYPE [186:18]
+    |       |   |   `--IDENT -> SuperClassA [186:18]
+    |       |   |--IDENT -> s [186:30]
+    |       |   `--SEMI -> ; [186:31]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [187:8]
+    |       |   |--MODIFIERS -> MODIFIERS [187:8]
+    |       |   |--TYPE -> TYPE [187:8]
+    |       |   |   `--IDENT -> Object [187:8]
+    |       |   |--IDENT -> s2 [187:15]
+    |       |   `--SEMI -> ; [187:17]
+    |       `--RCURLY -> } [188:4]
+    |--CLASS_DEF -> CLASS_DEF [189:4]
+    |   |--MODIFIERS -> MODIFIERS [189:4]
+    |   |--LITERAL_CLASS -> class [189:4]
+    |   |--IDENT -> SuperClassA2 [189:10]
+    |   `--OBJBLOCK -> OBJBLOCK [189:22]
+    |       |--LCURLY -> { [189:22]
+    |       `--RCURLY -> } [189:23]
+    |--CLASS_DEF -> CLASS_DEF [196:4]
+    |   |--MODIFIERS -> MODIFIERS [196:4]
+    |   |   |--BLOCK_COMMENT_BEGIN -> /* [192:4]
+    |   |   |   |--COMMENT_CONTENT -> \n     * Note: inherited fields of a nested class shadow outer scope variables\n     *      Note: only if they are accessible!\n      [192:6]
+    |   |   |   `--BLOCK_COMMENT_END -> */ [195:5]
+    |   |   `--LITERAL_PUBLIC -> public [196:4]
+    |   |--LITERAL_CLASS -> class [196:11]
+    |   |--IDENT -> FieldAccessSuper [196:17]
+    |   |--EXTENDS_CLAUSE -> extends [196:34]
+    |   |   `--IDENT -> SuperClassA [196:42]
+    |   `--OBJBLOCK -> OBJBLOCK [196:54]
+    |       |--LCURLY -> { [196:54]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [197:8]
+    |       |   |--MODIFIERS -> MODIFIERS [197:8]
+    |       |   |   `--LITERAL_PRIVATE -> private [197:8]
+    |       |   |--TYPE -> TYPE [197:16]
+    |       |   |   `--IDENT -> SuperClassA [197:16]
+    |       |   |--IDENT -> s [197:28]
+    |       |   `--SEMI -> ; [197:29]
+    |       |--METHOD_DEF -> METHOD_DEF [199:8]
+    |       |   |--MODIFIERS -> MODIFIERS [199:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [199:8]
+    |       |   |--TYPE -> TYPE [199:15]
+    |       |   |   `--LITERAL_VOID -> void [199:15]
+    |       |   |--IDENT -> foo [199:20]
+    |       |   |--LPAREN -> ( [199:23]
+    |       |   |--PARAMETERS -> PARAMETERS [199:24]
+    |       |   |--RPAREN -> ) [199:24]
+    |       |   `--SLIST -> { [199:26]
+    |       |       |--EXPR -> EXPR [202:14]
+    |       |       |   `--ASSIGN -> = [202:14]
+    |       |       |       |--SINGLE_LINE_COMMENT -> // [200:12]
+    |       |       |       |   `--COMMENT_CONTENT ->  simple super field access\n [200:14]
+    |       |       |       |--SINGLE_LINE_COMMENT -> // [201:12]
+    |       |       |       |   `--COMMENT_CONTENT ->  Primary[Prefix[Name[s]]]\n [201:14]
+    |       |       |       |--IDENT -> s [202:12]
+    |       |       |       `--LITERAL_NEW -> new [202:16]
+    |       |       |           |--IDENT -> SuperClassA [202:20]
+    |       |       |           |--LPAREN -> ( [202:31]
+    |       |       |           |--ELIST -> ELIST [202:32]
+    |       |       |           `--RPAREN -> ) [202:32]
+    |       |       |--SEMI -> ; [202:33]
+    |       |       |--EXPR -> EXPR [206:24]
+    |       |       |   `--ASSIGN -> = [206:24]
+    |       |       |       |--DOT -> . [206:20]
+    |       |       |       |   |--DOT -> . [206:18]
+    |       |       |       |   |   |--SINGLE_LINE_COMMENT -> // [204:12]
+    |       |       |       |   |   |   `--COMMENT_CONTENT ->  access inherited field through primary\n [204:14]
+    |       |       |       |   |   |--SINGLE_LINE_COMMENT -> // [205:12]
+    |       |       |       |   |   |   `--COMMENT_CONTENT ->  Primary[ Prefix[Primary[(this)]], Suffix[s], Suffix[s2] ]\n [205:14]
+    |       |       |       |   |   |--LPAREN -> ( [206:12]
+    |       |       |       |   |   |--LITERAL_THIS -> this [206:13]
+    |       |       |       |   |   |--RPAREN -> ) [206:17]
+    |       |       |       |   |   `--IDENT -> s [206:19]
+    |       |       |       |   `--IDENT -> s2 [206:21]
+    |       |       |       `--LITERAL_NEW -> new [206:26]
+    |       |       |           |--IDENT -> SuperClassA2 [206:30]
+    |       |       |           |--LPAREN -> ( [206:42]
+    |       |       |           |--ELIST -> ELIST [206:43]
+    |       |       |           `--RPAREN -> ) [206:43]
+    |       |       |--SEMI -> ; [206:44]
+    |       |       |--EXPR -> EXPR [210:19]
+    |       |       |   `--ASSIGN -> = [210:19]
+    |       |       |       |--DOT -> . [210:15]
+    |       |       |       |   |--DOT -> . [210:13]
+    |       |       |       |   |   |--SINGLE_LINE_COMMENT -> // [208:12]
+    |       |       |       |   |   |   `--COMMENT_CONTENT ->  access inherited field, second 's' has inherited field 's2'\n [208:14]
+    |       |       |       |   |   |--SINGLE_LINE_COMMENT -> // [209:12]
+    |       |       |       |   |   |   `--COMMENT_CONTENT ->  Primary[Prefix[Name[s.s.s2]]]\n [209:14]
+    |       |       |       |   |   |--IDENT -> s [210:12]
+    |       |       |       |   |   `--IDENT -> s [210:14]
+    |       |       |       |   `--IDENT -> s2 [210:16]
+    |       |       |       `--LITERAL_NEW -> new [210:21]
+    |       |       |           |--IDENT -> SuperClassA2 [210:25]
+    |       |       |           |--LPAREN -> ( [210:37]
+    |       |       |           |--ELIST -> ELIST [210:38]
+    |       |       |           `--RPAREN -> ) [210:38]
+    |       |       |--SEMI -> ; [210:39]
+    |       |       |--EXPR -> EXPR [214:20]
+    |       |       |   `--ASSIGN -> = [214:20]
+    |       |       |       |--DOT -> . [214:17]
+    |       |       |       |   |--SINGLE_LINE_COMMENT -> // [212:12]
+    |       |       |       |   |   `--COMMENT_CONTENT ->  field access through super\n [212:14]
+    |       |       |       |   |--SINGLE_LINE_COMMENT -> // [213:12]
+    |       |       |       |   |   `--COMMENT_CONTENT ->  Primary[Prefix["super"], Suffix["field"]]\n [213:14]
+    |       |       |       |   |--LITERAL_SUPER -> super [214:12]
+    |       |       |       |   `--IDENT -> s [214:18]
+    |       |       |       `--LITERAL_NEW -> new [214:22]
+    |       |       |           |--IDENT -> SuperClassA [214:26]
+    |       |       |           |--LPAREN -> ( [214:37]
+    |       |       |           |--ELIST -> ELIST [214:38]
+    |       |       |           `--RPAREN -> ) [214:38]
+    |       |       |--SEMI -> ; [214:39]
+    |       |       |--EXPR -> EXPR [219:20]
+    |       |       |   `--ASSIGN -> = [219:20]
+    |       |       |       |--DOT -> . [218:33]
+    |       |       |       |   |--DOT -> . [218:28]
+    |       |       |       |   |   |--SINGLE_LINE_COMMENT -> // [216:12]
+    |       |       |       |   |   |   `--COMMENT_CONTENT ->  fully qualified case\n [216:14]
+    |       |       |       |   |   |--SINGLE_LINE_COMMENT -> // [217:12]
+    |       |       |       |   |   |   `--COMMENT_CONTENT ->  Primary[Prefix[Name[net...FieldAccessSuper]], Suffix[this], Suffix[s]]\n [217:14]
+    |       |       |       |   |   |--IDENT -> FieldAccessSuper [218:12]
+    |       |       |       |   |   `--LITERAL_THIS -> this [218:29]
+    |       |       |       |   `--IDENT -> s [218:34]
+    |       |       |       `--LITERAL_NEW -> new [219:22]
+    |       |       |           |--IDENT -> SuperClassA [219:26]
+    |       |       |           |--LPAREN -> ( [219:37]
+    |       |       |           |--ELIST -> ELIST [219:38]
+    |       |       |           `--RPAREN -> ) [219:38]
+    |       |       |--SEMI -> ; [219:39]
+    |       |       `--RCURLY -> } [220:8]
+    |       |--CLASS_DEF -> CLASS_DEF [222:8]
+    |       |   |--MODIFIERS -> MODIFIERS [222:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [222:8]
+    |       |   |--LITERAL_CLASS -> class [222:15]
+    |       |   |--IDENT -> Nested [222:21]
+    |       |   |--EXTENDS_CLAUSE -> extends [222:28]
+    |       |   |   `--IDENT -> SuperClassA [222:36]
+    |       |   `--OBJBLOCK -> OBJBLOCK [222:48]
+    |       |       |--LCURLY -> { [222:48]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [223:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [223:12]
+    |       |       |   |--TYPE -> TYPE [223:12]
+    |       |       |   |   `--IDENT -> SuperClassA [223:12]
+    |       |       |   |--IDENT -> a [223:24]
+    |       |       |   `--SEMI -> ; [223:25]
+    |       |       |--CLASS_DEF -> CLASS_DEF [224:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [224:12]
+    |       |       |   |--LITERAL_CLASS -> class [224:12]
+    |       |       |   |--IDENT -> SubscriptionAdapter [224:18]
+    |       |       |   `--OBJBLOCK -> OBJBLOCK [224:37]
+    |       |       |       |--LCURLY -> { [224:37]
+    |       |       |       `--RCURLY -> } [224:38]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [225:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [225:12]
+    |       |       |   |   `--FINAL -> final [225:12]
+    |       |       |   |--TYPE -> TYPE [225:34]
+    |       |       |   |   |--BLOCK_COMMENT_BEGIN -> /* [225:18]
+    |       |       |   |   |   |--COMMENT_CONTENT ->  synthetic  [225:20]
+    |       |       |   |   |   `--BLOCK_COMMENT_END -> */ [225:30]
+    |       |       |   |   `--IDENT -> SubscriptionAdapter [225:34]
+    |       |       |   |--IDENT -> this$0 [225:54]
+    |       |       |   |--ASSIGN -> = [225:61]
+    |       |       |   |   `--EXPR -> EXPR [225:63]
+    |       |       |   |       `--LITERAL_NULL -> null [225:63]
+    |       |       |   `--SEMI -> ; [225:67]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [226:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [226:12]
+    |       |       |   |   `--FINAL -> final [226:12]
+    |       |       |   |--TYPE -> TYPE [226:34]
+    |       |       |   |   |--BLOCK_COMMENT_BEGIN -> /* [226:18]
+    |       |       |   |   |   |--COMMENT_CONTENT ->  synthetic  [226:20]
+    |       |       |   |   |   `--BLOCK_COMMENT_END -> */ [226:30]
+    |       |       |   |   `--IDENT -> Object [226:34]
+    |       |       |   |--IDENT -> val$argHolder [226:41]
+    |       |       |   |--ASSIGN -> = [226:55]
+    |       |       |   |   `--EXPR -> EXPR [226:57]
+    |       |       |   |       `--LITERAL_NULL -> null [226:57]
+    |       |       |   `--SEMI -> ; [226:61]
+    |       |       |--METHOD_DEF -> METHOD_DEF [228:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [228:12]
+    |       |       |   |   `--LITERAL_PUBLIC -> public [228:12]
+    |       |       |   |--TYPE -> TYPE [228:19]
+    |       |       |   |   `--LITERAL_VOID -> void [228:19]
+    |       |       |   |--IDENT -> foo [228:24]
+    |       |       |   |--LPAREN -> ( [228:27]
+    |       |       |   |--PARAMETERS -> PARAMETERS [228:28]
+    |       |       |   |--RPAREN -> ) [228:28]
+    |       |       |   `--SLIST -> { [228:30]
+    |       |       |       |--EXPR -> EXPR [231:18]
+    |       |       |       |   `--ASSIGN -> = [231:18]
+    |       |       |       |       |--SINGLE_LINE_COMMENT -> // [229:16]
+    |       |       |       |       |   `--COMMENT_CONTENT ->  access enclosing super field\n [229:18]
+    |       |       |       |       |--SINGLE_LINE_COMMENT -> // [230:16]
+    |       |       |       |       |   `--COMMENT_CONTENT ->  Primary[Prefix[Name[s]]]\n [230:18]
+    |       |       |       |       |--IDENT -> s [231:16]
+    |       |       |       |       `--LITERAL_NEW -> new [231:20]
+    |       |       |       |           |--IDENT -> SuperClassA [231:24]
+    |       |       |       |           |--LPAREN -> ( [231:35]
+    |       |       |       |           |--ELIST -> ELIST [231:36]
+    |       |       |       |           `--RPAREN -> ) [231:36]
+    |       |       |       |--SEMI -> ; [231:37]
+    |       |       |       |--EXPR -> EXPR [235:19]
+    |       |       |       |   `--ASSIGN -> = [235:19]
+    |       |       |       |       |--SINGLE_LINE_COMMENT -> // [233:16]
+    |       |       |       |       |   `--COMMENT_CONTENT ->  access Nested inherited field\n [233:18]
+    |       |       |       |       |--SINGLE_LINE_COMMENT -> // [234:16]
+    |       |       |       |       |   `--COMMENT_CONTENT ->  Primary[Prefix[Name[bs]]]\n [234:18]
+    |       |       |       |       |--IDENT -> bs [235:16]
+    |       |       |       |       `--LITERAL_NEW -> new [235:21]
+    |       |       |       |           |--IDENT -> SuperClassA [235:25]
+    |       |       |       |           |--LPAREN -> ( [235:36]
+    |       |       |       |           |--ELIST -> ELIST [235:37]
+    |       |       |       |           `--RPAREN -> ) [235:37]
+    |       |       |       |--SEMI -> ; [235:38]
+    |       |       |       |--EXPR -> EXPR [240:49]
+    |       |       |       |   `--ASSIGN -> = [240:49]
+    |       |       |       |       |--DOT -> . [240:45]
+    |       |       |       |       |   |--DOT -> . [240:39]
+    |       |       |       |       |   |   |--DOT -> . [240:32]
+    |       |       |       |       |   |   |   |--SINGLE_LINE_COMMENT -> // [237:16]
+    |       |       |       |       |   |   |   |   `--COMMENT_CONTENT ->  access super field with fully qualified stuff\n [237:18]
+    |       |       |       |       |   |   |   |--SINGLE_LINE_COMMENT -> // [238:16]
+    |       |       |       |       |   |   |   |   `--COMMENT_CONTENT ->  Primary[Prefix["FieldAccessSuper"], Suffix[Nested],\n [238:18]
+    |       |       |       |       |   |   |   |--SINGLE_LINE_COMMENT -> // [239:16]
+    |       |       |       |       |   |   |   |   `--COMMENT_CONTENT ->                   Suffix["super"], Suffix["bs"]]\n [239:18]
+    |       |       |       |       |   |   |   |--IDENT -> FieldAccessSuper [240:16]
+    |       |       |       |       |   |   |   `--IDENT -> Nested [240:33]
+    |       |       |       |       |   |   `--LITERAL_SUPER -> super [240:40]
+    |       |       |       |       |   `--IDENT -> bs [240:46]
+    |       |       |       |       `--LITERAL_NEW -> new [240:51]
+    |       |       |       |           |--IDENT -> SuperClassA [240:55]
+    |       |       |       |           |--LPAREN -> ( [240:66]
+    |       |       |       |           |--ELIST -> ELIST [240:67]
+    |       |       |       |           `--RPAREN -> ) [240:67]
+    |       |       |       |--SEMI -> ; [240:68]
+    |       |       |       |--EXPR -> EXPR [244:41]
+    |       |       |       |   `--ASSIGN -> = [244:41]
+    |       |       |       |       |--DOT -> . [244:38]
+    |       |       |       |       |   |--DOT -> . [244:32]
+    |       |       |       |       |   |   |--SINGLE_LINE_COMMENT -> // [242:16]
+    |       |       |       |       |   |   |   `--COMMENT_CONTENT ->  refers to the enclosing class's immediate super class's field\n [242:18]
+    |       |       |       |       |   |   |--SINGLE_LINE_COMMENT -> // [243:16]
+    |       |       |       |       |   |   |   `--COMMENT_CONTENT ->  Primary[Prefix["FieldAccessSuper"], Suffix["super"], Suffix["s"]]\n [243:18]
+    |       |       |       |       |   |   |--IDENT -> FieldAccessSuper [244:16]
+    |       |       |       |       |   |   `--LITERAL_SUPER -> super [244:33]
+    |       |       |       |       |   `--IDENT -> s [244:39]
+    |       |       |       |       `--LITERAL_NEW -> new [244:43]
+    |       |       |       |           |--IDENT -> SuperClassA [244:47]
+    |       |       |       |           |--LPAREN -> ( [244:58]
+    |       |       |       |           |--ELIST -> ELIST [244:59]
+    |       |       |       |           `--RPAREN -> ) [244:59]
+    |       |       |       |--SEMI -> ; [244:60]
+    |       |       |       `--RCURLY -> } [245:12]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [246:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [246:12]
+    |       |       |   |--TYPE -> TYPE [246:12]
+    |       |       |   |   `--IDENT -> Object [246:12]
+    |       |       |   |--IDENT -> x [246:19]
+    |       |       |   |--ASSIGN -> = [246:21]
+    |       |       |   |   `--EXPR -> EXPR [246:61]
+    |       |       |   |       `--METHOD_CALL -> ( [246:61]
+    |       |       |   |           |--DOT -> . [246:35]
+    |       |       |   |           |   |--IDENT -> Collections [246:23]
+    |       |       |   |           |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [246:36]
+    |       |       |   |           |   |   |--GENERIC_START -> < [246:36]
+    |       |       |   |           |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [246:37]
+    |       |       |   |           |   |   |   `--IDENT -> String [246:37]
+    |       |       |   |           |   |   |--COMMA -> , [246:43]
+    |       |       |   |           |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [246:45]
+    |       |       |   |           |   |   |   `--IDENT -> Integer [246:45]
+    |       |       |   |           |   |   `--GENERIC_END -> > [246:52]
+    |       |       |   |           |   `--IDENT -> emptyMap [246:53]
+    |       |       |   |           |--ELIST -> ELIST [246:62]
+    |       |       |   |           `--RPAREN -> ) [246:62]
+    |       |       |   `--SEMI -> ; [246:63]
+    |       |       |--CTOR_DEF -> CTOR_DEF [248:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [248:12]
+    |       |       |   |--IDENT -> Nested [248:12]
+    |       |       |   |--LPAREN -> ( [248:18]
+    |       |       |   |--PARAMETERS -> PARAMETERS [248:19]
+    |       |       |   |--RPAREN -> ) [248:19]
+    |       |       |   `--SLIST -> { [248:21]
+    |       |       |       |--SUPER_CTOR_CALL -> super [249:16]
+    |       |       |       |   |--LPAREN -> ( [249:21]
+    |       |       |       |   |--ELIST -> ELIST [249:22]
+    |       |       |       |   |--RPAREN -> ) [249:22]
+    |       |       |       |   `--SEMI -> ; [249:23]
+    |       |       |       `--RCURLY -> } [250:12]
+    |       |       |--METHOD_DEF -> METHOD_DEF [252:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [252:12]
+    |       |       |   |--TYPE -> TYPE [252:12]
+    |       |       |   |   `--LITERAL_INT -> int [252:12]
+    |       |       |   |--IDENT -> bar [252:16]
+    |       |       |   |--LPAREN -> ( [252:19]
+    |       |       |   |--PARAMETERS -> PARAMETERS [252:20]
+    |       |       |   |--RPAREN -> ) [252:20]
+    |       |       |   `--SLIST -> { [252:22]
+    |       |       |       |--LITERAL_RETURN -> return [253:16]
+    |       |       |       |   |--EXPR -> EXPR [253:37]
+    |       |       |       |   |   `--METHOD_CALL -> ( [253:37]
+    |       |       |       |   |       |--DOT -> . [253:28]
+    |       |       |       |   |       |   |--LITERAL_SUPER -> super [253:23]
+    |       |       |       |   |       |   `--IDENT -> hashCode [253:29]
+    |       |       |       |   |       |--ELIST -> ELIST [253:38]
+    |       |       |       |   |       `--RPAREN -> ) [253:38]
+    |       |       |       |   `--SEMI -> ; [253:39]
+    |       |       |       `--RCURLY -> } [254:12]
+    |       |       |--METHOD_DEF -> METHOD_DEF [256:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [256:12]
+    |       |       |   |--TYPE -> TYPE [256:12]
+    |       |       |   |   `--LITERAL_BOOLEAN -> boolean [256:12]
+    |       |       |   |--IDENT -> method [256:20]
+    |       |       |   |--LPAREN -> ( [256:26]
+    |       |       |   |--PARAMETERS -> PARAMETERS [256:27]
+    |       |       |   |--RPAREN -> ) [256:27]
+    |       |       |   `--SLIST -> { [256:29]
+    |       |       |       |--LITERAL_RETURN -> return [257:16]
+    |       |       |       |   |--EXPR -> EXPR [257:35]
+    |       |       |       |   |   `--METHOD_CALL -> ( [257:35]
+    |       |       |       |   |       |--DOT -> . [257:28]
+    |       |       |       |   |       |   |--LITERAL_SUPER -> super [257:23]
+    |       |       |       |   |       |   `--IDENT -> equals [257:29]
+    |       |       |       |   |       |--ELIST -> ELIST [257:36]
+    |       |       |       |   |       |   `--EXPR -> EXPR [257:36]
+    |       |       |       |   |       |       `--LITERAL_NEW -> new [257:36]
+    |       |       |       |   |       |           |--IDENT -> Object [257:40]
+    |       |       |       |   |       |           |--LPAREN -> ( [257:46]
+    |       |       |       |   |       |           |--ELIST -> ELIST [257:47]
+    |       |       |       |   |       |           `--RPAREN -> ) [257:47]
+    |       |       |       |   |       `--RPAREN -> ) [257:48]
+    |       |       |       |   `--SEMI -> ; [257:49]
+    |       |       |       `--RCURLY -> } [258:12]
+    |       |       `--RCURLY -> } [259:8]
+    |       `--RCURLY -> } [260:4]
+    `--RCURLY -> } [263:0]
+RECORD_DEF -> RECORD_DEF [265:0]
+|--MODIFIERS -> MODIFIERS [265:0]
+|--LITERAL_RECORD -> record [265:0]
+|--IDENT -> TestRecord [265:7]
+|--LPAREN -> ( [265:17]
+|--RECORD_COMPONENTS -> RECORD_COMPONENTS [265:18]
+|   |--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [265:18]
+|   |   |--ANNOTATIONS -> ANNOTATIONS [265:18]
+|   |   |--TYPE -> TYPE [265:18]
+|   |   |   |--LITERAL_INT -> int [265:18]
+|   |   |   `--ARRAY_DECLARATOR -> [ [265:21]
+|   |   |       `--RBRACK -> ] [265:22]
+|   |   `--IDENT -> x [265:24]
+|   |--COMMA -> , [265:25]
+|   `--RECORD_COMPONENT_DEF -> RECORD_COMPONENT_DEF [265:27]
+|       |--ANNOTATIONS -> ANNOTATIONS [265:27]
+|       |--TYPE -> TYPE [265:27]
+|       |   |--LITERAL_INT -> int [265:27]
+|       |   `--ARRAY_DECLARATOR -> [ [265:30]
+|       |       `--RBRACK -> ] [265:31]
+|       |--ELLIPSIS -> ... [265:32]
+|       `--IDENT -> y [265:36]
+|--RPAREN -> ) [265:37]
+`--OBJBLOCK -> OBJBLOCK [265:39]
+    |--LCURLY -> { [265:39]
+    |--METHOD_DEF -> METHOD_DEF [266:4]
+    |   |--MODIFIERS -> MODIFIERS [266:4]
+    |   |--TYPE -> TYPE [266:4]
+    |   |   `--LITERAL_VOID -> void [266:4]
+    |   |--IDENT -> foo [266:9]
+    |   |--LPAREN -> ( [266:12]
+    |   |--PARAMETERS -> PARAMETERS [266:13]
+    |   |--RPAREN -> ) [266:13]
+    |   `--SLIST -> { [266:15]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [267:8]
+    |       |   |--MODIFIERS -> MODIFIERS [267:8]
+    |       |   |--TYPE -> TYPE [267:8]
+    |       |   |   `--IDENT -> Runnable [267:8]
+    |       |   |--IDENT -> r11 [267:17]
+    |       |   `--ASSIGN -> = [267:21]
+    |       |       `--EXPR -> EXPR [267:27]
+    |       |           `--METHOD_REF -> :: [267:27]
+    |       |               |--IDENT -> Main [267:23]
+    |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [267:29]
+    |       |               |   |--GENERIC_START -> < [267:29]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [267:30]
+    |       |               |   |   `--IDENT -> String [267:30]
+    |       |               |   `--GENERIC_END -> > [267:36]
+    |       |               `--LITERAL_NEW -> new [267:37]
+    |       |--SEMI -> ; [267:40]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [268:8]
+    |       |   |--MODIFIERS -> MODIFIERS [268:8]
+    |       |   |--TYPE -> TYPE [268:8]
+    |       |   |   |--IDENT -> IntFunction [268:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [268:19]
+    |       |   |       |--GENERIC_START -> < [268:19]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [268:20]
+    |       |   |       |   |--LITERAL_INT -> int [268:20]
+    |       |   |       |   `--ARRAY_DECLARATOR -> [ [268:23]
+    |       |   |       |       `--RBRACK -> ] [268:24]
+    |       |   |       `--GENERIC_END -> > [268:25]
+    |       |   |--IDENT -> r13 [268:27]
+    |       |   `--ASSIGN -> = [268:31]
+    |       |       `--EXPR -> EXPR [268:38]
+    |       |           `--METHOD_REF -> :: [268:38]
+    |       |               |--LITERAL_INT -> int [268:33]
+    |       |               |--ARRAY_DECLARATOR -> [ [268:36]
+    |       |               |   `--RBRACK -> ] [268:37]
+    |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [268:40]
+    |       |               |   |--GENERIC_START -> < [268:40]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [268:41]
+    |       |               |   |   `--IDENT -> String [268:41]
+    |       |               |   `--GENERIC_END -> > [268:47]
+    |       |               `--LITERAL_NEW -> new [268:48]
+    |       |--SEMI -> ; [268:51]
+    |       |--SINGLE_LINE_COMMENT -> // [268:53]
+    |       |   `--COMMENT_CONTENT ->  produces the same results\n [268:55]
+    |       `--RCURLY -> } [269:4]
+    `--RCURLY -> } [270:0]
+SEMI -> ; [272:0]
+SEMI -> ; [272:1]
+SEMI -> ; [272:2]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon2.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon2.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon2.txt
@@ -0,0 +1,262 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [5:24]
+|--DOT -> . [5:24]
+|   |--DOT -> . [5:16]
+|   |   |--DOT -> . [3:21]
+|   |   |   |--DOT -> . [2:39]
+|   |   |   |   |--DOT -> . [2:28]
+|   |   |   |   |   |--IDENT -> com [2:9]
+|   |   |   |   |   `--IDENT -> puppycrawl [2:29]
+|   |   |   |   `--IDENT -> tools [3:16]
+|   |   |   `--IDENT -> checkstyle [4:16]
+|   |   `--IDENT -> grammar [5:17]
+|   `--IDENT -> antlr4 [6:16]
+`--SEMI -> ; [7:8]
+IMPORT -> import [9:0]
+|--DOT -> . [9:16]
+|   |--DOT -> . [9:11]
+|   |   |--IDENT -> java [9:7]
+|   |   `--IDENT -> util [9:12]
+|   `--IDENT -> ArrayList [9:17]
+`--SEMI -> ; [9:26]
+IMPORT -> import [10:0]
+|--DOT -> . [10:16]
+|   |--DOT -> . [10:11]
+|   |   |--IDENT -> java [10:7]
+|   |   `--IDENT -> util [10:12]
+|   `--IDENT -> List [10:17]
+`--SEMI -> ; [10:21]
+CLASS_DEF -> CLASS_DEF [12:0]
+|--MODIFIERS -> MODIFIERS [12:0]
+|   `--LITERAL_PUBLIC -> public [12:0]
+|--LITERAL_CLASS -> class [12:7]
+|--IDENT -> InputAntlr4AstRegressionUncommon2 [12:13]
+`--OBJBLOCK -> OBJBLOCK [12:47]
+    |--LCURLY -> { [12:47]
+    |--ANNOTATION_DEF -> ANNOTATION_DEF [13:4]
+    |   |--MODIFIERS -> MODIFIERS [13:4]
+    |   |   `--LITERAL_PUBLIC -> public [13:4]
+    |   |--AT -> @ [13:11]
+    |   |--LITERAL_INTERFACE -> interface [13:12]
+    |   |--IDENT -> PackgeAnno [13:22]
+    |   `--OBJBLOCK -> OBJBLOCK [13:33]
+    |       |--LCURLY -> { [13:33]
+    |       `--RCURLY -> } [14:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [15:4]
+    |   |--MODIFIERS -> MODIFIERS [15:4]
+    |   |   `--ANNOTATION -> ANNOTATION [15:4]
+    |   |       |--AT -> @ [15:4]
+    |   |       `--IDENT -> Nullable [15:5]
+    |   |--TYPE -> TYPE [15:14]
+    |   |   |--IDENT -> List [15:14]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [15:18]
+    |   |       |--GENERIC_START -> < [15:18]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [15:19]
+    |   |       |   `--IDENT -> Integer [15:19]
+    |   |       `--GENERIC_END -> > [15:26]
+    |   |--IDENT -> x [15:28]
+    |   |--ASSIGN -> = [15:30]
+    |   |   `--EXPR -> EXPR [15:32]
+    |   |       `--LITERAL_NEW -> new [15:32]
+    |   |           |--IDENT -> ArrayList [15:36]
+    |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [15:45]
+    |   |           |   |--GENERIC_START -> < [15:45]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [15:46]
+    |   |           |   |   `--IDENT -> Integer [15:46]
+    |   |           |   `--GENERIC_END -> > [15:53]
+    |   |           |--LPAREN -> ( [15:54]
+    |   |           |--ELIST -> ELIST [15:55]
+    |   |           `--RPAREN -> ) [15:55]
+    |   `--SEMI -> ; [15:56]
+    |--ENUM_DEF -> ENUM_DEF [16:4]
+    |   |--MODIFIERS -> MODIFIERS [16:4]
+    |   |--ENUM -> enum [16:4]
+    |   |--IDENT -> FPMethodArgs [17:4]
+    |   `--OBJBLOCK -> OBJBLOCK [18:4]
+    |       |--LCURLY -> { [18:4]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [20:8]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [20:8]
+    |       |   `--IDENT -> IGNN [20:8]
+    |       |--COMMA -> , [20:12]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [21:8]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [21:8]
+    |       |   `--IDENT -> IIGNN [21:8]
+    |       |--COMMA -> , [21:13]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [22:8]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [22:8]
+    |       |   `--IDENT -> GNNII [22:8]
+    |       |--COMMA -> , [22:13]
+    |       |--ENUM_CONSTANT_DEF -> ENUM_CONSTANT_DEF [23:8]
+    |       |   |--ANNOTATIONS -> ANNOTATIONS [23:8]
+    |       |   `--IDENT -> GNNC [23:8]
+    |       |--SEMI -> ; [23:12]
+    |       |--SEMI -> ; [23:13]
+    |       |--SEMI -> ; [23:14]
+    |       |--SEMI -> ; [23:15]
+    |       |--SEMI -> ; [23:16]
+    |       `--RCURLY -> } [24:4]
+    |--INTERFACE_DEF -> INTERFACE_DEF [25:4]
+    |   |--MODIFIERS -> MODIFIERS [25:4]
+    |   |   `--LITERAL_PUBLIC -> public [25:4]
+    |   |--LITERAL_INTERFACE -> interface [26:4]
+    |   |--IDENT -> IntEnum [27:4]
+    |   `--OBJBLOCK -> OBJBLOCK [28:4]
+    |       |--LCURLY -> { [28:4]
+    |       `--RCURLY -> } [29:4]
+    |--ANNOTATION_DEF -> ANNOTATION_DEF [31:4]
+    |   |--MODIFIERS -> MODIFIERS [31:4]
+    |   |   `--LITERAL_PRIVATE -> private [31:4]
+    |   |--AT -> @ [32:4]
+    |   |--LITERAL_INTERFACE -> interface [32:5]
+    |   |--IDENT -> MyOtherAnno [33:4]
+    |   `--OBJBLOCK -> OBJBLOCK [34:4]
+    |       |--LCURLY -> { [34:4]
+    |       |--CLASS_DEF -> CLASS_DEF [35:8]
+    |       |   |--MODIFIERS -> MODIFIERS [35:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [35:8]
+    |       |   |--LITERAL_CLASS -> class [35:15]
+    |       |   |--IDENT -> Test [36:8]
+    |       |   `--OBJBLOCK -> OBJBLOCK [36:13]
+    |       |       |--LCURLY -> { [36:13]
+    |       |       `--RCURLY -> } [36:14]
+    |       |--ENUM_DEF -> ENUM_DEF [37:8]
+    |       |   |--MODIFIERS -> MODIFIERS [37:8]
+    |       |   |--ENUM -> enum [37:8]
+    |       |   |--IDENT -> TestEnum [38:8]
+    |       |   `--OBJBLOCK -> OBJBLOCK [38:16]
+    |       |       |--LCURLY -> { [38:16]
+    |       |       `--RCURLY -> } [38:17]
+    |       |--ANNOTATION_DEF -> ANNOTATION_DEF [39:8]
+    |       |   |--MODIFIERS -> MODIFIERS [39:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [39:8]
+    |       |   |--AT -> @ [39:15]
+    |       |   |--LITERAL_INTERFACE -> interface [39:16]
+    |       |   |--IDENT -> InnerAnnoDeclaration [40:8]
+    |       |   `--OBJBLOCK -> OBJBLOCK [40:28]
+    |       |       |--LCURLY -> { [40:28]
+    |       |       `--RCURLY -> } [40:29]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [41:8]
+    |       |   |--MODIFIERS -> MODIFIERS [41:8]
+    |       |   |--TYPE -> TYPE [41:8]
+    |       |   |   `--LITERAL_INT -> int [41:8]
+    |       |   |--IDENT -> x [41:12]
+    |       |   |--ASSIGN -> = [41:14]
+    |       |   |   `--EXPR -> EXPR [41:16]
+    |       |   |       `--NUM_INT -> 0 [41:16]
+    |       |   `--SEMI -> ; [41:17]
+    |       |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [42:8]
+    |       |   |--MODIFIERS -> MODIFIERS [42:8]
+    |       |   |--TYPE -> TYPE [42:8]
+    |       |   |   `--LITERAL_INT -> int [42:8]
+    |       |   |--IDENT -> method [42:12]
+    |       |   |--LPAREN -> ( [42:18]
+    |       |   |--RPAREN -> ) [42:19]
+    |       |   `--SEMI -> ; [42:20]
+    |       |--SEMI -> ; [43:8]
+    |       |--SEMI -> ; [43:9]
+    |       |--SEMI -> ; [43:10]
+    |       |--SEMI -> ; [43:11]
+    |       |--SEMI -> ; [43:12]
+    |       `--RCURLY -> } [44:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [45:4]
+    |   |--MODIFIERS -> MODIFIERS [45:4]
+    |   |   `--LITERAL_PRIVATE -> private [45:4]
+    |   |--TYPE -> TYPE [45:12]
+    |   |   `--IDENT -> String [45:12]
+    |   |--IDENT -> str [45:19]
+    |   |--ASSIGN -> = [45:23]
+    |   |   `--EXPR -> EXPR [46:88]
+    |   |       `--PLUS -> + [46:88]
+    |   |           |--PLUS -> + [46:85]
+    |   |           |   |--PLUS -> + [46:82]
+    |   |           |   |   |--PLUS -> + [46:79]
+    |   |           |   |   |   |--PLUS -> + [46:76]
+    |   |           |   |   |   |   |--PLUS -> + [46:73]
+    |   |           |   |   |   |   |   |--PLUS -> + [46:70]
+    |   |           |   |   |   |   |   |   |--PLUS -> + [46:67]
+    |   |           |   |   |   |   |   |   |   |--PLUS -> + [46:64]
+    |   |           |   |   |   |   |   |   |   |   |--PLUS -> + [46:61]
+    |   |           |   |   |   |   |   |   |   |   |   |--PLUS -> + [46:58]
+    |   |           |   |   |   |   |   |   |   |   |   |   |--PLUS -> + [46:55]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |--PLUS -> + [46:52]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |--PLUS -> + [46:49]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |--PLUS -> + [46:46]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |--PLUS -> + [46:43]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |--PLUS -> + [46:40]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |--PLUS -> + [46:37]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |--PLUS -> + [46:34]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |--PLUS -> + [46:31]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |--PLUS -> + [46:28]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |--PLUS -> + [46:25]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |--PLUS -> + [46:22]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |--PLUS -> + [46:19]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |--PLUS -> + [46:16]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |--PLUS -> + [46:13]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |--PLUS -> + [46:10]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |--STRING_LITERAL -> "" [45:25]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:11]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:14]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:17]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:20]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:23]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:26]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:29]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:32]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:35]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:38]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:41]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:44]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:47]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:50]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:53]
+    |   |           |   |   |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:56]
+    |   |           |   |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:59]
+    |   |           |   |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:62]
+    |   |           |   |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:65]
+    |   |           |   |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:68]
+    |   |           |   |   |   |   |   |   `--STRING_LITERAL -> "" [46:71]
+    |   |           |   |   |   |   |   `--STRING_LITERAL -> "" [46:74]
+    |   |           |   |   |   |   `--STRING_LITERAL -> "" [46:77]
+    |   |           |   |   |   `--STRING_LITERAL -> "" [46:80]
+    |   |           |   |   `--STRING_LITERAL -> "" [46:83]
+    |   |           |   `--STRING_LITERAL -> "" [46:86]
+    |   |           `--STRING_LITERAL -> "" [46:89]
+    |   `--SEMI -> ; [46:91]
+    |--VARIABLE_DEF -> VARIABLE_DEF [47:4]
+    |   |--MODIFIERS -> MODIFIERS [47:4]
+    |   |--TYPE -> TYPE [47:4]
+    |   |   `--LITERAL_INT -> int [47:4]
+    |   |--IDENT -> z [47:8]
+    |   |--ASSIGN -> = [47:10]
+    |   |   `--EXPR -> EXPR [47:15]
+    |   |       `--PLUS -> + [47:15]
+    |   |           |--NUM_INT -> 42 [47:12]
+    |   |           `--NUM_INT -> 42 [47:17]
+    |   `--SEMI -> ; [47:19]
+    |--ANNOTATION_DEF -> ANNOTATION_DEF [48:4]
+    |   |--MODIFIERS -> MODIFIERS [48:4]
+    |   |--AT -> @ [48:4]
+    |   |--LITERAL_INTERFACE -> interface [48:6]
+    |   |--IDENT -> Foo [48:16]
+    |   `--OBJBLOCK -> OBJBLOCK [48:20]
+    |       |--LCURLY -> { [48:20]
+    |       |--ANNOTATION_FIELD_DEF -> ANNOTATION_FIELD_DEF [49:8]
+    |       |   |--MODIFIERS -> MODIFIERS [49:8]
+    |       |   |--TYPE -> TYPE [49:8]
+    |       |   |   |--IDENT -> String [49:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [49:19]
+    |       |   |       `--RBRACK -> ] [49:20]
+    |       |   |--IDENT -> v1 [49:15]
+    |       |   |--LPAREN -> ( [49:17]
+    |       |   |--RPAREN -> ) [49:18]
+    |       |   `--SEMI -> ; [49:21]
+    |       `--RCURLY -> } [50:4]
+    |--ANNOTATION_DEF -> ANNOTATION_DEF [51:4]
+    |   |--MODIFIERS -> MODIFIERS [51:4]
+    |   |--AT -> @ [51:4]
+    |   |--LITERAL_INTERFACE -> interface [51:5]
+    |   |--IDENT -> Nullable [51:15]
+    |   `--OBJBLOCK -> OBJBLOCK [51:23]
+    |       |--LCURLY -> { [51:23]
+    |       `--RCURLY -> } [51:24]
+    `--RCURLY -> } [52:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon3.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon3.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon3.txt
@@ -0,0 +1,333 @@
+SINGLE_LINE_COMMENT -> // [1:0]
+`--COMMENT_CONTENT -> non-compiled with javac: Compilable with Java16\n [1:2]
+PACKAGE_DEF -> package [2:0]
+|--ANNOTATIONS -> ANNOTATIONS [2:47]
+|--DOT -> . [2:47]
+|   |--DOT -> . [2:39]
+|   |   |--DOT -> . [2:28]
+|   |   |   |--DOT -> . [2:22]
+|   |   |   |   |--DOT -> . [2:11]
+|   |   |   |   |   |--IDENT -> com [2:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [2:12]
+|   |   |   |   `--IDENT -> tools [2:23]
+|   |   |   `--IDENT -> checkstyle [2:29]
+|   |   `--IDENT -> grammar [2:40]
+|   `--IDENT -> antlr4 [2:48]
+`--SEMI -> ; [2:54]
+CLASS_DEF -> CLASS_DEF [4:0]
+|--MODIFIERS -> MODIFIERS [4:0]
+|   `--LITERAL_PUBLIC -> public [4:0]
+|--LITERAL_CLASS -> class [4:7]
+|--IDENT -> InputAntlr4AstRegressionUncommon3 [4:13]
+|--IMPLEMENTS_CLAUSE -> implements [4:47]
+|   `--IDENT -> AutoCloseable [4:58]
+`--OBJBLOCK -> OBJBLOCK [4:72]
+    |--LCURLY -> { [4:72]
+    |--METHOD_DEF -> METHOD_DEF [5:4]
+    |   |--MODIFIERS -> MODIFIERS [5:4]
+    |   |   |--ANNOTATION -> ANNOTATION [5:4]
+    |   |   |   |--AT -> @ [5:4]
+    |   |   |   `--IDENT -> Override [5:5]
+    |   |   `--LITERAL_PUBLIC -> public [6:4]
+    |   |--TYPE -> TYPE [6:11]
+    |   |   `--LITERAL_VOID -> void [6:11]
+    |   |--IDENT -> close [6:16]
+    |   |--LPAREN -> ( [6:21]
+    |   |--PARAMETERS -> PARAMETERS [6:22]
+    |   |--RPAREN -> ) [6:22]
+    |   |--LITERAL_THROWS -> throws [6:24]
+    |   |   `--IDENT -> Exception [6:31]
+    |   `--SLIST -> { [6:41]
+    |       `--RCURLY -> } [8:4]
+    |--INTERFACE_DEF -> INTERFACE_DEF [10:4]
+    |   |--MODIFIERS -> MODIFIERS [10:4]
+    |   |--LITERAL_INTERFACE -> interface [10:4]
+    |   |--IDENT -> SAM [10:14]
+    |   `--OBJBLOCK -> OBJBLOCK [10:18]
+    |       |--LCURLY -> { [10:18]
+    |       |--METHOD_DEF -> METHOD_DEF [11:8]
+    |       |   |--MODIFIERS -> MODIFIERS [11:8]
+    |       |   |--TYPE -> TYPE [11:8]
+    |       |   |   `--LITERAL_INT -> int [11:8]
+    |       |   |--IDENT -> m [11:12]
+    |       |   |--LPAREN -> ( [11:13]
+    |       |   |--PARAMETERS -> PARAMETERS [11:14]
+    |       |   |--RPAREN -> ) [11:14]
+    |       |   `--SEMI -> ; [11:15]
+    |       `--RCURLY -> } [12:4]
+    |--INTERFACE_DEF -> INTERFACE_DEF [14:4]
+    |   |--MODIFIERS -> MODIFIERS [14:4]
+    |   |--LITERAL_INTERFACE -> interface [14:4]
+    |   |--IDENT -> SuperI [14:14]
+    |   `--OBJBLOCK -> OBJBLOCK [14:21]
+    |       |--LCURLY -> { [14:21]
+    |       |--METHOD_DEF -> METHOD_DEF [15:8]
+    |       |   |--MODIFIERS -> MODIFIERS [15:8]
+    |       |   |   |--LITERAL_PUBLIC -> public [15:8]
+    |       |   |   `--LITERAL_DEFAULT -> default [15:15]
+    |       |   |--TYPE -> TYPE [15:23]
+    |       |   |   `--LITERAL_INT -> int [15:23]
+    |       |   |--IDENT -> foo [15:27]
+    |       |   |--LPAREN -> ( [15:30]
+    |       |   |--PARAMETERS -> PARAMETERS [15:31]
+    |       |   |--RPAREN -> ) [15:31]
+    |       |   `--SLIST -> { [15:33]
+    |       |       |--LITERAL_RETURN -> return [15:35]
+    |       |       |   |--EXPR -> EXPR [15:42]
+    |       |       |   |   `--NUM_INT -> 1234 [15:42]
+    |       |       |   `--SEMI -> ; [15:46]
+    |       |       `--RCURLY -> } [15:48]
+    |       `--RCURLY -> } [16:4]
+    |--INTERFACE_DEF -> INTERFACE_DEF [18:4]
+    |   |--MODIFIERS -> MODIFIERS [18:4]
+    |   |--LITERAL_INTERFACE -> interface [18:4]
+    |   |--IDENT -> I [18:14]
+    |   |--EXTENDS_CLAUSE -> extends [18:16]
+    |   |   `--IDENT -> SuperI [18:24]
+    |   `--OBJBLOCK -> OBJBLOCK [18:31]
+    |       |--LCURLY -> { [18:31]
+    |       `--RCURLY -> } [19:4]
+    |--INTERFACE_DEF -> INTERFACE_DEF [21:4]
+    |   |--MODIFIERS -> MODIFIERS [21:4]
+    |   |--LITERAL_INTERFACE -> interface [21:4]
+    |   |--IDENT -> T [21:14]
+    |   |--EXTENDS_CLAUSE -> extends [21:16]
+    |   |   `--IDENT -> I [21:24]
+    |   `--OBJBLOCK -> OBJBLOCK [21:26]
+    |       |--LCURLY -> { [21:26]
+    |       |--METHOD_DEF -> METHOD_DEF [22:8]
+    |       |   |--MODIFIERS -> MODIFIERS [22:8]
+    |       |   |   |--LITERAL_PUBLIC -> public [22:8]
+    |       |   |   `--LITERAL_DEFAULT -> default [22:15]
+    |       |   |--TYPE -> TYPE [22:23]
+    |       |   |   `--IDENT -> SAM [22:23]
+    |       |   |--IDENT -> boo [22:27]
+    |       |   |--LPAREN -> ( [22:30]
+    |       |   |--PARAMETERS -> PARAMETERS [22:31]
+    |       |   |--RPAREN -> ) [22:31]
+    |       |   `--SLIST -> { [22:33]
+    |       |       |--LITERAL_RETURN -> return [22:35]
+    |       |       |   |--EXPR -> EXPR [22:49]
+    |       |       |   |   `--METHOD_REF -> :: [22:49]
+    |       |       |   |       |--DOT -> . [22:43]
+    |       |       |   |       |   |--IDENT -> I [22:42]
+    |       |       |   |       |   `--LITERAL_SUPER -> super [22:44]
+    |       |       |   |       `--IDENT -> foo [22:51]
+    |       |       |   `--SEMI -> ; [22:54]
+    |       |       `--RCURLY -> } [22:56]
+    |       `--RCURLY -> } [23:4]
+    |--INTERFACE_DEF -> INTERFACE_DEF [25:4]
+    |   |--MODIFIERS -> MODIFIERS [25:4]
+    |   |--LITERAL_INTERFACE -> interface [25:4]
+    |   |--IDENT -> DSPRI [25:14]
+    |   `--OBJBLOCK -> OBJBLOCK [25:20]
+    |       |--LCURLY -> { [25:20]
+    |       |--METHOD_DEF -> METHOD_DEF [25:22]
+    |       |   |--MODIFIERS -> MODIFIERS [25:22]
+    |       |   |--TYPE -> TYPE [25:22]
+    |       |   |   `--IDENT -> String [25:22]
+    |       |   |--IDENT -> m [25:29]
+    |       |   |--LPAREN -> ( [25:30]
+    |       |   |--PARAMETERS -> PARAMETERS [25:31]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [25:31]
+    |       |   |       |--MODIFIERS -> MODIFIERS [25:31]
+    |       |   |       |--TYPE -> TYPE [25:31]
+    |       |   |       |   `--IDENT -> String [25:31]
+    |       |   |       `--IDENT -> a [25:38]
+    |       |   |--RPAREN -> ) [25:39]
+    |       |   `--SEMI -> ; [25:40]
+    |       `--RCURLY -> } [25:42]
+    |--INTERFACE_DEF -> INTERFACE_DEF [27:4]
+    |   |--MODIFIERS -> MODIFIERS [27:4]
+    |   |--LITERAL_INTERFACE -> interface [27:4]
+    |   |--IDENT -> DSPRA [27:14]
+    |   `--OBJBLOCK -> OBJBLOCK [27:20]
+    |       |--LCURLY -> { [27:20]
+    |       |--METHOD_DEF -> METHOD_DEF [28:8]
+    |       |   |--MODIFIERS -> MODIFIERS [28:8]
+    |       |   |   `--LITERAL_DEFAULT -> default [28:8]
+    |       |   |--TYPE -> TYPE [28:16]
+    |       |   |   `--IDENT -> String [28:16]
+    |       |   |--IDENT -> xsA__ [28:23]
+    |       |   |--LPAREN -> ( [28:28]
+    |       |   |--PARAMETERS -> PARAMETERS [28:29]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [28:29]
+    |       |   |       |--MODIFIERS -> MODIFIERS [28:29]
+    |       |   |       |--TYPE -> TYPE [28:29]
+    |       |   |       |   `--IDENT -> String [28:29]
+    |       |   |       `--IDENT -> s [28:36]
+    |       |   |--RPAREN -> ) [28:37]
+    |       |   `--SLIST -> { [28:39]
+    |       |       |--LITERAL_RETURN -> return [29:12]
+    |       |       |   |--EXPR -> EXPR [29:29]
+    |       |       |   |   `--PLUS -> + [29:29]
+    |       |       |   |       |--STRING_LITERAL -> "A__xsA:" [29:19]
+    |       |       |   |       `--IDENT -> s [29:31]
+    |       |       |   `--SEMI -> ; [29:32]
+    |       |       `--RCURLY -> } [30:8]
+    |       |--METHOD_DEF -> METHOD_DEF [32:8]
+    |       |   |--MODIFIERS -> MODIFIERS [32:8]
+    |       |   |   `--LITERAL_DEFAULT -> default [32:8]
+    |       |   |--TYPE -> TYPE [32:16]
+    |       |   |   `--IDENT -> String [32:16]
+    |       |   |--IDENT -> xsAB_ [32:23]
+    |       |   |--LPAREN -> ( [32:28]
+    |       |   |--PARAMETERS -> PARAMETERS [32:29]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [32:29]
+    |       |   |       |--MODIFIERS -> MODIFIERS [32:29]
+    |       |   |       |--TYPE -> TYPE [32:29]
+    |       |   |       |   `--IDENT -> String [32:29]
+    |       |   |       `--IDENT -> s [32:36]
+    |       |   |--RPAREN -> ) [32:37]
+    |       |   `--SLIST -> { [32:39]
+    |       |       |--LITERAL_RETURN -> return [33:12]
+    |       |       |   |--EXPR -> EXPR [33:29]
+    |       |       |   |   `--PLUS -> + [33:29]
+    |       |       |   |       |--STRING_LITERAL -> "AB_xsA:" [33:19]
+    |       |       |   |       `--IDENT -> s [33:31]
+    |       |       |   `--SEMI -> ; [33:32]
+    |       |       `--RCURLY -> } [34:8]
+    |       `--RCURLY -> } [36:4]
+    |--INTERFACE_DEF -> INTERFACE_DEF [38:4]
+    |   |--MODIFIERS -> MODIFIERS [38:4]
+    |   |--LITERAL_INTERFACE -> interface [38:4]
+    |   |--IDENT -> DSPRB [38:14]
+    |   |--EXTENDS_CLAUSE -> extends [38:20]
+    |   |   `--IDENT -> DSPRA [38:28]
+    |   `--OBJBLOCK -> OBJBLOCK [38:34]
+    |       |--LCURLY -> { [38:34]
+    |       |--METHOD_DEF -> METHOD_DEF [40:8]
+    |       |   |--MODIFIERS -> MODIFIERS [40:8]
+    |       |   |   `--LITERAL_DEFAULT -> default [40:8]
+    |       |   |--TYPE -> TYPE [40:16]
+    |       |   |   `--IDENT -> String [40:16]
+    |       |   |--IDENT -> xsAB_ [40:23]
+    |       |   |--LPAREN -> ( [40:28]
+    |       |   |--PARAMETERS -> PARAMETERS [40:29]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [40:29]
+    |       |   |       |--MODIFIERS -> MODIFIERS [40:29]
+    |       |   |       |--TYPE -> TYPE [40:29]
+    |       |   |       |   `--IDENT -> String [40:29]
+    |       |   |       `--IDENT -> s [40:36]
+    |       |   |--RPAREN -> ) [40:37]
+    |       |   `--SLIST -> { [40:39]
+    |       |       |--LITERAL_RETURN -> return [41:12]
+    |       |       |   |--EXPR -> EXPR [41:29]
+    |       |       |   |   `--PLUS -> + [41:29]
+    |       |       |   |       |--STRING_LITERAL -> "AB_xsB:" [41:19]
+    |       |       |   |       `--IDENT -> s [41:31]
+    |       |       |   `--SEMI -> ; [41:32]
+    |       |       `--RCURLY -> } [42:8]
+    |       |--METHOD_DEF -> METHOD_DEF [44:8]
+    |       |   |--MODIFIERS -> MODIFIERS [44:8]
+    |       |   |   `--LITERAL_DEFAULT -> default [44:8]
+    |       |   |--TYPE -> TYPE [44:16]
+    |       |   |   `--IDENT -> String [44:16]
+    |       |   |--IDENT -> xs_B_ [44:23]
+    |       |   |--LPAREN -> ( [44:28]
+    |       |   |--PARAMETERS -> PARAMETERS [44:29]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [44:29]
+    |       |   |       |--MODIFIERS -> MODIFIERS [44:29]
+    |       |   |       |--TYPE -> TYPE [44:29]
+    |       |   |       |   `--IDENT -> String [44:29]
+    |       |   |       `--IDENT -> s [44:36]
+    |       |   |--RPAREN -> ) [44:37]
+    |       |   `--SLIST -> { [44:39]
+    |       |       |--LITERAL_RETURN -> return [45:12]
+    |       |       |   |--EXPR -> EXPR [45:29]
+    |       |       |   |   `--PLUS -> + [45:29]
+    |       |       |   |       |--STRING_LITERAL -> "_B_xsB:" [45:19]
+    |       |       |   |       `--IDENT -> s [45:31]
+    |       |       |   `--SEMI -> ; [45:32]
+    |       |       `--RCURLY -> } [46:8]
+    |       `--RCURLY -> } [48:4]
+    |--CLASS_DEF -> CLASS_DEF [50:4]
+    |   |--MODIFIERS -> MODIFIERS [50:4]
+    |   |   `--LITERAL_PUBLIC -> public [50:4]
+    |   |--LITERAL_CLASS -> class [50:11]
+    |   |--IDENT -> MethodReferenceTestSuperDefault [50:17]
+    |   |--IMPLEMENTS_CLAUSE -> implements [50:49]
+    |   |   `--IDENT -> DSPRB [50:60]
+    |   `--OBJBLOCK -> OBJBLOCK [50:66]
+    |       |--LCURLY -> { [50:66]
+    |       |--METHOD_DEF -> METHOD_DEF [52:8]
+    |       |   |--MODIFIERS -> MODIFIERS [52:8]
+    |       |   |   `--LITERAL_PUBLIC -> public [52:8]
+    |       |   |--TYPE -> TYPE [52:15]
+    |       |   |   `--LITERAL_VOID -> void [52:15]
+    |       |   |--IDENT -> testMethodReferenceSuper [52:20]
+    |       |   |--LPAREN -> ( [52:44]
+    |       |   |--PARAMETERS -> PARAMETERS [52:45]
+    |       |   |--RPAREN -> ) [52:45]
+    |       |   `--SLIST -> { [52:47]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [53:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [53:12]
+    |       |       |   |--TYPE -> TYPE [53:12]
+    |       |       |   |   `--IDENT -> DSPRI [53:12]
+    |       |       |   `--IDENT -> q [53:18]
+    |       |       |--SEMI -> ; [53:19]
+    |       |       |--EXPR -> EXPR [55:14]
+    |       |       |   `--ASSIGN -> = [55:14]
+    |       |       |       |--IDENT -> q [55:12]
+    |       |       |       `--METHOD_REF -> :: [55:27]
+    |       |       |           |--DOT -> . [55:21]
+    |       |       |           |   |--IDENT -> DSPRB [55:16]
+    |       |       |           |   `--LITERAL_SUPER -> super [55:22]
+    |       |       |           `--IDENT -> xsA__ [55:29]
+    |       |       |--SEMI -> ; [55:34]
+    |       |       |--EXPR -> EXPR [57:14]
+    |       |       |   `--ASSIGN -> = [57:14]
+    |       |       |       |--IDENT -> q [57:12]
+    |       |       |       `--METHOD_REF -> :: [57:27]
+    |       |       |           |--DOT -> . [57:21]
+    |       |       |           |   |--IDENT -> DSPRB [57:16]
+    |       |       |           |   `--LITERAL_SUPER -> super [57:22]
+    |       |       |           `--IDENT -> xsAB_ [57:29]
+    |       |       |--SEMI -> ; [57:34]
+    |       |       |--EXPR -> EXPR [59:14]
+    |       |       |   `--ASSIGN -> = [59:14]
+    |       |       |       |--IDENT -> q [59:12]
+    |       |       |       `--METHOD_REF -> :: [59:27]
+    |       |       |           |--DOT -> . [59:21]
+    |       |       |           |   |--IDENT -> DSPRB [59:16]
+    |       |       |           |   `--LITERAL_SUPER -> super [59:22]
+    |       |       |           `--IDENT -> xs_B_ [59:29]
+    |       |       |--SEMI -> ; [59:34]
+    |       |       `--RCURLY -> } [60:8]
+    |       `--RCURLY -> } [62:4]
+    |--METHOD_DEF -> METHOD_DEF [64:4]
+    |   |--MODIFIERS -> MODIFIERS [64:4]
+    |   |--TYPE -> TYPE [64:4]
+    |   |   `--LITERAL_VOID -> void [64:4]
+    |   |--IDENT -> test [64:9]
+    |   |--LPAREN -> ( [64:13]
+    |   |--PARAMETERS -> PARAMETERS [64:14]
+    |   |--RPAREN -> ) [64:14]
+    |   |--LITERAL_THROWS -> throws [64:16]
+    |   |   `--IDENT -> Exception [64:23]
+    |   `--SLIST -> { [64:33]
+    |       |--LITERAL_TRY -> try [65:8]
+    |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [65:12]
+    |       |   |   |--LPAREN -> ( [65:12]
+    |       |   |   |--RESOURCES -> RESOURCES [65:46]
+    |       |   |   |   `--RESOURCE -> RESOURCE [65:46]
+    |       |   |   |       `--DOT -> . [65:46]
+    |       |   |   |           |--IDENT -> InputAntlr4AstRegressionUncommon3 [65:13]
+    |       |   |   |           `--LITERAL_THIS -> this [65:47]
+    |       |   |   `--RPAREN -> ) [65:51]
+    |       |   `--SLIST -> { [65:53]
+    |       |       |--EXPR -> EXPR [66:30]
+    |       |       |   `--METHOD_CALL -> ( [66:30]
+    |       |       |       |--DOT -> . [66:22]
+    |       |       |       |   |--DOT -> . [66:18]
+    |       |       |       |   |   |--IDENT -> System [66:12]
+    |       |       |       |   |   `--IDENT -> out [66:19]
+    |       |       |       |   `--IDENT -> println [66:23]
+    |       |       |       |--ELIST -> ELIST [66:31]
+    |       |       |       |   `--EXPR -> EXPR [66:31]
+    |       |       |       |       `--STRING_LITERAL -> "Unable to process" [66:31]
+    |       |       |       `--RPAREN -> ) [66:50]
+    |       |       |--SEMI -> ; [66:51]
+    |       |       `--RCURLY -> } [67:8]
+    |       `--RCURLY -> } [68:4]
+    `--RCURLY -> } [70:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon4.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon4.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon4.java
@@ -0,0 +1,87 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOError;
+import java.io.IOException;
+import java.util.function.BiFunction;
+
+public class InputAntlr4AstRegressionUncommon4 {
+    void m3() throws FileNotFoundException {
+        int x = 2 /* comment */ + 2;
+        int y = (/*comment */ x /*comment */ + 2);
+        m4(/* param1 */ x, /* param2 */ x);
+        BiFunction<Integer, Integer, Integer> lambda9
+                = (/* param1 */ a, /* param2 */ b) -> a + b;
+
+        BiFunction<Integer, Integer, Integer> lambda13
+                = (/* param1 */ a /* param1 */, /* param2 */ b /* param2 */) -> a + b;
+    }
+
+    int m4 (int z, int q) throws FileNotFoundException {
+        try (
+                java
+                        .
+                        io
+                        .
+                        BufferedReader bufferedReader
+                        = new BufferedReader(new FileReader("path"))) {
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return 8;
+    }
+
+    class CelebrationLunch<I extends Number, L extends Number, D extends Number> {
+        class Section<A extends Number, B extends Number, C extends Number> {
+
+        }
+    }
+
+    private CelebrationLunch<Integer,Long,Double> inner;
+    CelebrationLunch<Integer, Long, Double>
+            .Section<Number, Number, Number> section = inner.new Section<>();
+
+    @NonNull String p1 = "hello";
+    void method() {
+        try {
+            System.out.println();
+        }
+        catch (@NonNull IOError | ArithmeticException e) {
+
+        }
+    }
+
+    void m23(Class<Object> clazz) {
+        if (InputAntlr4AstRegressionUncommon4.this != null) {
+        }
+    }
+
+}
+
+class H006_ComplexConstructors<T> {
+    public <V> H006_ComplexConstructors(T t, V v) {
+    }
+
+    static {
+        H006_ComplexConstructors<? extends Number> x =
+                new <String>H006_ComplexConstructors<Integer>(0, "");
+    }
+
+
+    class Inner3 {
+        Inner3(int x) {
+            H006_ComplexConstructors<Integer> instance =
+                    new <String>H006_ComplexConstructors<Integer>(0, "");
+            Object o = instance.new Inner3(5).new <String>InnerInner3("hey");
+        }
+
+        class InnerInner3 {
+            <D> InnerInner3(D in) {
+            }
+        }
+    }
+}
+
+@interface NonNull{}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon4.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon4.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionUncommon4.txt
@@ -0,0 +1,672 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+IMPORT -> import [3:0]
+|--DOT -> . [3:14]
+|   |--DOT -> . [3:11]
+|   |   |--IDENT -> java [3:7]
+|   |   `--IDENT -> io [3:12]
+|   `--IDENT -> BufferedReader [3:15]
+`--SEMI -> ; [3:29]
+IMPORT -> import [4:0]
+|--DOT -> . [4:14]
+|   |--DOT -> . [4:11]
+|   |   |--IDENT -> java [4:7]
+|   |   `--IDENT -> io [4:12]
+|   `--IDENT -> FileNotFoundException [4:15]
+`--SEMI -> ; [4:36]
+IMPORT -> import [5:0]
+|--DOT -> . [5:14]
+|   |--DOT -> . [5:11]
+|   |   |--IDENT -> java [5:7]
+|   |   `--IDENT -> io [5:12]
+|   `--IDENT -> FileReader [5:15]
+`--SEMI -> ; [5:25]
+IMPORT -> import [6:0]
+|--DOT -> . [6:14]
+|   |--DOT -> . [6:11]
+|   |   |--IDENT -> java [6:7]
+|   |   `--IDENT -> io [6:12]
+|   `--IDENT -> IOError [6:15]
+`--SEMI -> ; [6:22]
+IMPORT -> import [7:0]
+|--DOT -> . [7:14]
+|   |--DOT -> . [7:11]
+|   |   |--IDENT -> java [7:7]
+|   |   `--IDENT -> io [7:12]
+|   `--IDENT -> IOException [7:15]
+`--SEMI -> ; [7:26]
+IMPORT -> import [8:0]
+|--DOT -> . [8:25]
+|   |--DOT -> . [8:16]
+|   |   |--DOT -> . [8:11]
+|   |   |   |--IDENT -> java [8:7]
+|   |   |   `--IDENT -> util [8:12]
+|   |   `--IDENT -> function [8:17]
+|   `--IDENT -> BiFunction [8:26]
+`--SEMI -> ; [8:36]
+CLASS_DEF -> CLASS_DEF [10:0]
+|--MODIFIERS -> MODIFIERS [10:0]
+|   `--LITERAL_PUBLIC -> public [10:0]
+|--LITERAL_CLASS -> class [10:7]
+|--IDENT -> InputAntlr4AstRegressionUncommon4 [10:13]
+`--OBJBLOCK -> OBJBLOCK [10:47]
+    |--LCURLY -> { [10:47]
+    |--METHOD_DEF -> METHOD_DEF [11:4]
+    |   |--MODIFIERS -> MODIFIERS [11:4]
+    |   |--TYPE -> TYPE [11:4]
+    |   |   `--LITERAL_VOID -> void [11:4]
+    |   |--IDENT -> m3 [11:9]
+    |   |--LPAREN -> ( [11:11]
+    |   |--PARAMETERS -> PARAMETERS [11:12]
+    |   |--RPAREN -> ) [11:12]
+    |   |--LITERAL_THROWS -> throws [11:14]
+    |   |   `--IDENT -> FileNotFoundException [11:21]
+    |   `--SLIST -> { [11:43]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [12:8]
+    |       |   |--MODIFIERS -> MODIFIERS [12:8]
+    |       |   |--TYPE -> TYPE [12:8]
+    |       |   |   `--LITERAL_INT -> int [12:8]
+    |       |   |--IDENT -> x [12:12]
+    |       |   `--ASSIGN -> = [12:14]
+    |       |       `--EXPR -> EXPR [12:32]
+    |       |           |--BLOCK_COMMENT_BEGIN -> /* [12:18]
+    |       |           |   |--COMMENT_CONTENT ->  comment  [12:20]
+    |       |           |   `--BLOCK_COMMENT_END -> */ [12:28]
+    |       |           `--PLUS -> + [12:32]
+    |       |               |--NUM_INT -> 2 [12:16]
+    |       |               `--NUM_INT -> 2 [12:34]
+    |       |--SEMI -> ; [12:35]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [13:8]
+    |       |   |--MODIFIERS -> MODIFIERS [13:8]
+    |       |   |--TYPE -> TYPE [13:8]
+    |       |   |   `--LITERAL_INT -> int [13:8]
+    |       |   |--IDENT -> y [13:12]
+    |       |   `--ASSIGN -> = [13:14]
+    |       |       `--EXPR -> EXPR [13:16]
+    |       |           |--LPAREN -> ( [13:16]
+    |       |           |--BLOCK_COMMENT_BEGIN -> /* [13:32]
+    |       |           |   |--COMMENT_CONTENT -> comment  [13:34]
+    |       |           |   `--BLOCK_COMMENT_END -> */ [13:41]
+    |       |           |--PLUS -> + [13:45]
+    |       |           |   |--BLOCK_COMMENT_BEGIN -> /* [13:17]
+    |       |           |   |   |--COMMENT_CONTENT -> comment  [13:19]
+    |       |           |   |   `--BLOCK_COMMENT_END -> */ [13:26]
+    |       |           |   |--IDENT -> x [13:30]
+    |       |           |   `--NUM_INT -> 2 [13:47]
+    |       |           `--RPAREN -> ) [13:48]
+    |       |--SEMI -> ; [13:49]
+    |       |--EXPR -> EXPR [14:10]
+    |       |   `--METHOD_CALL -> ( [14:10]
+    |       |       |--IDENT -> m4 [14:8]
+    |       |       |--ELIST -> ELIST [14:24]
+    |       |       |   |--EXPR -> EXPR [14:24]
+    |       |       |   |   |--BLOCK_COMMENT_BEGIN -> /* [14:11]
+    |       |       |   |   |   |--COMMENT_CONTENT ->  param1  [14:13]
+    |       |       |   |   |   `--BLOCK_COMMENT_END -> */ [14:20]
+    |       |       |   |   `--IDENT -> x [14:24]
+    |       |       |   |--COMMA -> , [14:25]
+    |       |       |   `--EXPR -> EXPR [14:40]
+    |       |       |       |--BLOCK_COMMENT_BEGIN -> /* [14:27]
+    |       |       |       |   |--COMMENT_CONTENT ->  param2  [14:29]
+    |       |       |       |   `--BLOCK_COMMENT_END -> */ [14:36]
+    |       |       |       `--IDENT -> x [14:40]
+    |       |       `--RPAREN -> ) [14:41]
+    |       |--SEMI -> ; [14:42]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [15:8]
+    |       |   |--MODIFIERS -> MODIFIERS [15:8]
+    |       |   |--TYPE -> TYPE [15:8]
+    |       |   |   |--IDENT -> BiFunction [15:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [15:18]
+    |       |   |       |--GENERIC_START -> < [15:18]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [15:19]
+    |       |   |       |   `--IDENT -> Integer [15:19]
+    |       |   |       |--COMMA -> , [15:26]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [15:28]
+    |       |   |       |   `--IDENT -> Integer [15:28]
+    |       |   |       |--COMMA -> , [15:35]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [15:37]
+    |       |   |       |   `--IDENT -> Integer [15:37]
+    |       |   |       `--GENERIC_END -> > [15:44]
+    |       |   |--IDENT -> lambda9 [15:46]
+    |       |   `--ASSIGN -> = [16:16]
+    |       |       `--LAMBDA -> -> [16:51]
+    |       |           |--LPAREN -> ( [16:18]
+    |       |           |--PARAMETERS -> PARAMETERS [16:32]
+    |       |           |   |--PARAMETER_DEF -> PARAMETER_DEF [16:32]
+    |       |           |   |   |--MODIFIERS -> MODIFIERS [16:32]
+    |       |           |   |   |--TYPE -> TYPE [16:32]
+    |       |           |   |   |--BLOCK_COMMENT_BEGIN -> /* [16:19]
+    |       |           |   |   |   |--COMMENT_CONTENT ->  param1  [16:21]
+    |       |           |   |   |   `--BLOCK_COMMENT_END -> */ [16:28]
+    |       |           |   |   `--IDENT -> a [16:32]
+    |       |           |   |--COMMA -> , [16:33]
+    |       |           |   `--PARAMETER_DEF -> PARAMETER_DEF [16:48]
+    |       |           |       |--MODIFIERS -> MODIFIERS [16:48]
+    |       |           |       |--TYPE -> TYPE [16:48]
+    |       |           |       |--BLOCK_COMMENT_BEGIN -> /* [16:35]
+    |       |           |       |   |--COMMENT_CONTENT ->  param2  [16:37]
+    |       |           |       |   `--BLOCK_COMMENT_END -> */ [16:44]
+    |       |           |       `--IDENT -> b [16:48]
+    |       |           |--RPAREN -> ) [16:49]
+    |       |           `--EXPR -> EXPR [16:56]
+    |       |               `--PLUS -> + [16:56]
+    |       |                   |--IDENT -> a [16:54]
+    |       |                   `--IDENT -> b [16:58]
+    |       |--SEMI -> ; [16:59]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [18:8]
+    |       |   |--MODIFIERS -> MODIFIERS [18:8]
+    |       |   |--TYPE -> TYPE [18:8]
+    |       |   |   |--IDENT -> BiFunction [18:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [18:18]
+    |       |   |       |--GENERIC_START -> < [18:18]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [18:19]
+    |       |   |       |   `--IDENT -> Integer [18:19]
+    |       |   |       |--COMMA -> , [18:26]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [18:28]
+    |       |   |       |   `--IDENT -> Integer [18:28]
+    |       |   |       |--COMMA -> , [18:35]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [18:37]
+    |       |   |       |   `--IDENT -> Integer [18:37]
+    |       |   |       `--GENERIC_END -> > [18:44]
+    |       |   |--IDENT -> lambda13 [18:46]
+    |       |   `--ASSIGN -> = [19:16]
+    |       |       `--LAMBDA -> -> [19:77]
+    |       |           |--LPAREN -> ( [19:18]
+    |       |           |--PARAMETERS -> PARAMETERS [19:32]
+    |       |           |   |--PARAMETER_DEF -> PARAMETER_DEF [19:32]
+    |       |           |   |   |--MODIFIERS -> MODIFIERS [19:32]
+    |       |           |   |   |--TYPE -> TYPE [19:32]
+    |       |           |   |   |--BLOCK_COMMENT_BEGIN -> /* [19:19]
+    |       |           |   |   |   |--COMMENT_CONTENT ->  param1  [19:21]
+    |       |           |   |   |   `--BLOCK_COMMENT_END -> */ [19:28]
+    |       |           |   |   `--IDENT -> a [19:32]
+    |       |           |   |--BLOCK_COMMENT_BEGIN -> /* [19:34]
+    |       |           |   |   |--COMMENT_CONTENT ->  param1  [19:36]
+    |       |           |   |   `--BLOCK_COMMENT_END -> */ [19:43]
+    |       |           |   |--COMMA -> , [19:46]
+    |       |           |   `--PARAMETER_DEF -> PARAMETER_DEF [19:61]
+    |       |           |       |--MODIFIERS -> MODIFIERS [19:61]
+    |       |           |       |--TYPE -> TYPE [19:61]
+    |       |           |       |--BLOCK_COMMENT_BEGIN -> /* [19:48]
+    |       |           |       |   |--COMMENT_CONTENT ->  param2  [19:50]
+    |       |           |       |   `--BLOCK_COMMENT_END -> */ [19:57]
+    |       |           |       `--IDENT -> b [19:61]
+    |       |           |--BLOCK_COMMENT_BEGIN -> /* [19:63]
+    |       |           |   |--COMMENT_CONTENT ->  param2  [19:65]
+    |       |           |   `--BLOCK_COMMENT_END -> */ [19:72]
+    |       |           |--RPAREN -> ) [19:75]
+    |       |           `--EXPR -> EXPR [19:82]
+    |       |               `--PLUS -> + [19:82]
+    |       |                   |--IDENT -> a [19:80]
+    |       |                   `--IDENT -> b [19:84]
+    |       |--SEMI -> ; [19:85]
+    |       `--RCURLY -> } [20:4]
+    |--METHOD_DEF -> METHOD_DEF [22:4]
+    |   |--MODIFIERS -> MODIFIERS [22:4]
+    |   |--TYPE -> TYPE [22:4]
+    |   |   `--LITERAL_INT -> int [22:4]
+    |   |--IDENT -> m4 [22:8]
+    |   |--LPAREN -> ( [22:11]
+    |   |--PARAMETERS -> PARAMETERS [22:12]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [22:12]
+    |   |   |   |--MODIFIERS -> MODIFIERS [22:12]
+    |   |   |   |--TYPE -> TYPE [22:12]
+    |   |   |   |   `--LITERAL_INT -> int [22:12]
+    |   |   |   `--IDENT -> z [22:16]
+    |   |   |--COMMA -> , [22:17]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [22:19]
+    |   |       |--MODIFIERS -> MODIFIERS [22:19]
+    |   |       |--TYPE -> TYPE [22:19]
+    |   |       |   `--LITERAL_INT -> int [22:19]
+    |   |       `--IDENT -> q [22:23]
+    |   |--RPAREN -> ) [22:24]
+    |   |--LITERAL_THROWS -> throws [22:26]
+    |   |   `--IDENT -> FileNotFoundException [22:33]
+    |   `--SLIST -> { [22:55]
+    |       |--LITERAL_TRY -> try [23:8]
+    |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [23:12]
+    |       |   |   |--LPAREN -> ( [23:12]
+    |       |   |   |--RESOURCES -> RESOURCES [27:24]
+    |       |   |   |   `--RESOURCE -> RESOURCE [27:24]
+    |       |   |   |       |--MODIFIERS -> MODIFIERS [27:24]
+    |       |   |   |       |--TYPE -> TYPE [27:24]
+    |       |   |   |       |   `--DOT -> . [27:24]
+    |       |   |   |       |       |--DOT -> . [25:24]
+    |       |   |   |       |       |   |--IDENT -> java [24:16]
+    |       |   |   |       |       |   `--IDENT -> io [26:24]
+    |       |   |   |       |       `--IDENT -> BufferedReader [28:24]
+    |       |   |   |       |--IDENT -> bufferedReader [28:39]
+    |       |   |   |       `--ASSIGN -> = [29:24]
+    |       |   |   |           `--EXPR -> EXPR [29:26]
+    |       |   |   |               `--LITERAL_NEW -> new [29:26]
+    |       |   |   |                   |--IDENT -> BufferedReader [29:30]
+    |       |   |   |                   |--LPAREN -> ( [29:44]
+    |       |   |   |                   |--ELIST -> ELIST [29:45]
+    |       |   |   |                   |   `--EXPR -> EXPR [29:45]
+    |       |   |   |                   |       `--LITERAL_NEW -> new [29:45]
+    |       |   |   |                   |           |--IDENT -> FileReader [29:49]
+    |       |   |   |                   |           |--LPAREN -> ( [29:59]
+    |       |   |   |                   |           |--ELIST -> ELIST [29:60]
+    |       |   |   |                   |           |   `--EXPR -> EXPR [29:60]
+    |       |   |   |                   |           |       `--STRING_LITERAL -> "path" [29:60]
+    |       |   |   |                   |           `--RPAREN -> ) [29:66]
+    |       |   |   |                   `--RPAREN -> ) [29:67]
+    |       |   |   `--RPAREN -> ) [29:68]
+    |       |   |--SLIST -> { [29:70]
+    |       |   |   `--RCURLY -> } [30:8]
+    |       |   `--LITERAL_CATCH -> catch [30:10]
+    |       |       |--LPAREN -> ( [30:16]
+    |       |       |--PARAMETER_DEF -> PARAMETER_DEF [30:17]
+    |       |       |   |--MODIFIERS -> MODIFIERS [30:17]
+    |       |       |   |--TYPE -> TYPE [30:17]
+    |       |       |   |   `--IDENT -> IOException [30:17]
+    |       |       |   `--IDENT -> e [30:29]
+    |       |       |--RPAREN -> ) [30:30]
+    |       |       `--SLIST -> { [30:32]
+    |       |           |--EXPR -> EXPR [31:29]
+    |       |           |   `--METHOD_CALL -> ( [31:29]
+    |       |           |       |--DOT -> . [31:13]
+    |       |           |       |   |--IDENT -> e [31:12]
+    |       |           |       |   `--IDENT -> printStackTrace [31:14]
+    |       |           |       |--ELIST -> ELIST [31:30]
+    |       |           |       `--RPAREN -> ) [31:30]
+    |       |           |--SEMI -> ; [31:31]
+    |       |           `--RCURLY -> } [32:8]
+    |       |--LITERAL_RETURN -> return [33:8]
+    |       |   |--EXPR -> EXPR [33:15]
+    |       |   |   `--NUM_INT -> 8 [33:15]
+    |       |   `--SEMI -> ; [33:16]
+    |       `--RCURLY -> } [34:4]
+    |--CLASS_DEF -> CLASS_DEF [36:4]
+    |   |--MODIFIERS -> MODIFIERS [36:4]
+    |   |--LITERAL_CLASS -> class [36:4]
+    |   |--IDENT -> CelebrationLunch [36:10]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [36:26]
+    |   |   |--GENERIC_START -> < [36:26]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [36:27]
+    |   |   |   |--IDENT -> I [36:27]
+    |   |   |   `--TYPE_UPPER_BOUNDS -> extends [36:29]
+    |   |   |       `--IDENT -> Number [36:37]
+    |   |   |--COMMA -> , [36:43]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [36:45]
+    |   |   |   |--IDENT -> L [36:45]
+    |   |   |   `--TYPE_UPPER_BOUNDS -> extends [36:47]
+    |   |   |       `--IDENT -> Number [36:55]
+    |   |   |--COMMA -> , [36:61]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [36:63]
+    |   |   |   |--IDENT -> D [36:63]
+    |   |   |   `--TYPE_UPPER_BOUNDS -> extends [36:65]
+    |   |   |       `--IDENT -> Number [36:73]
+    |   |   `--GENERIC_END -> > [36:79]
+    |   `--OBJBLOCK -> OBJBLOCK [36:81]
+    |       |--LCURLY -> { [36:81]
+    |       |--CLASS_DEF -> CLASS_DEF [37:8]
+    |       |   |--MODIFIERS -> MODIFIERS [37:8]
+    |       |   |--LITERAL_CLASS -> class [37:8]
+    |       |   |--IDENT -> Section [37:14]
+    |       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [37:21]
+    |       |   |   |--GENERIC_START -> < [37:21]
+    |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [37:22]
+    |       |   |   |   |--IDENT -> A [37:22]
+    |       |   |   |   `--TYPE_UPPER_BOUNDS -> extends [37:24]
+    |       |   |   |       `--IDENT -> Number [37:32]
+    |       |   |   |--COMMA -> , [37:38]
+    |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [37:40]
+    |       |   |   |   |--IDENT -> B [37:40]
+    |       |   |   |   `--TYPE_UPPER_BOUNDS -> extends [37:42]
+    |       |   |   |       `--IDENT -> Number [37:50]
+    |       |   |   |--COMMA -> , [37:56]
+    |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [37:58]
+    |       |   |   |   |--IDENT -> C [37:58]
+    |       |   |   |   `--TYPE_UPPER_BOUNDS -> extends [37:60]
+    |       |   |   |       `--IDENT -> Number [37:68]
+    |       |   |   `--GENERIC_END -> > [37:74]
+    |       |   `--OBJBLOCK -> OBJBLOCK [37:76]
+    |       |       |--LCURLY -> { [37:76]
+    |       |       `--RCURLY -> } [39:8]
+    |       `--RCURLY -> } [40:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [42:4]
+    |   |--MODIFIERS -> MODIFIERS [42:4]
+    |   |   `--LITERAL_PRIVATE -> private [42:4]
+    |   |--TYPE -> TYPE [42:12]
+    |   |   |--IDENT -> CelebrationLunch [42:12]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [42:28]
+    |   |       |--GENERIC_START -> < [42:28]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:29]
+    |   |       |   `--IDENT -> Integer [42:29]
+    |   |       |--COMMA -> , [42:36]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:37]
+    |   |       |   `--IDENT -> Long [42:37]
+    |   |       |--COMMA -> , [42:41]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [42:42]
+    |   |       |   `--IDENT -> Double [42:42]
+    |   |       `--GENERIC_END -> > [42:48]
+    |   |--IDENT -> inner [42:50]
+    |   `--SEMI -> ; [42:55]
+    |--VARIABLE_DEF -> VARIABLE_DEF [44:12]
+    |   |--MODIFIERS -> MODIFIERS [44:12]
+    |   |--TYPE -> TYPE [44:12]
+    |   |   `--DOT -> . [44:12]
+    |   |       |--IDENT -> CelebrationLunch [43:4]
+    |   |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [43:20]
+    |   |       |   |--GENERIC_START -> < [43:20]
+    |   |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [43:21]
+    |   |       |   |   `--IDENT -> Integer [43:21]
+    |   |       |   |--COMMA -> , [43:28]
+    |   |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [43:30]
+    |   |       |   |   `--IDENT -> Long [43:30]
+    |   |       |   |--COMMA -> , [43:34]
+    |   |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [43:36]
+    |   |       |   |   `--IDENT -> Double [43:36]
+    |   |       |   `--GENERIC_END -> > [43:42]
+    |   |       |--IDENT -> Section [44:13]
+    |   |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [44:20]
+    |   |           |--GENERIC_START -> < [44:20]
+    |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [44:21]
+    |   |           |   `--IDENT -> Number [44:21]
+    |   |           |--COMMA -> , [44:27]
+    |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [44:29]
+    |   |           |   `--IDENT -> Number [44:29]
+    |   |           |--COMMA -> , [44:35]
+    |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [44:37]
+    |   |           |   `--IDENT -> Number [44:37]
+    |   |           `--GENERIC_END -> > [44:43]
+    |   |--IDENT -> section [44:45]
+    |   |--ASSIGN -> = [44:53]
+    |   |   `--EXPR -> EXPR [44:60]
+    |   |       `--DOT -> . [44:60]
+    |   |           |--IDENT -> inner [44:55]
+    |   |           `--LITERAL_NEW -> new [44:61]
+    |   |               |--IDENT -> Section [44:65]
+    |   |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [44:72]
+    |   |               |   |--GENERIC_START -> < [44:72]
+    |   |               |   `--GENERIC_END -> > [44:73]
+    |   |               |--LPAREN -> ( [44:74]
+    |   |               |--ELIST -> ELIST [44:75]
+    |   |               `--RPAREN -> ) [44:75]
+    |   `--SEMI -> ; [44:76]
+    |--VARIABLE_DEF -> VARIABLE_DEF [46:4]
+    |   |--MODIFIERS -> MODIFIERS [46:4]
+    |   |   `--ANNOTATION -> ANNOTATION [46:4]
+    |   |       |--AT -> @ [46:4]
+    |   |       `--IDENT -> NonNull [46:5]
+    |   |--TYPE -> TYPE [46:13]
+    |   |   `--IDENT -> String [46:13]
+    |   |--IDENT -> p1 [46:20]
+    |   |--ASSIGN -> = [46:23]
+    |   |   `--EXPR -> EXPR [46:25]
+    |   |       `--STRING_LITERAL -> "hello" [46:25]
+    |   `--SEMI -> ; [46:32]
+    |--METHOD_DEF -> METHOD_DEF [47:4]
+    |   |--MODIFIERS -> MODIFIERS [47:4]
+    |   |--TYPE -> TYPE [47:4]
+    |   |   `--LITERAL_VOID -> void [47:4]
+    |   |--IDENT -> method [47:9]
+    |   |--LPAREN -> ( [47:15]
+    |   |--PARAMETERS -> PARAMETERS [47:16]
+    |   |--RPAREN -> ) [47:16]
+    |   `--SLIST -> { [47:18]
+    |       |--LITERAL_TRY -> try [48:8]
+    |       |   |--SLIST -> { [48:12]
+    |       |   |   |--EXPR -> EXPR [49:30]
+    |       |   |   |   `--METHOD_CALL -> ( [49:30]
+    |       |   |   |       |--DOT -> . [49:22]
+    |       |   |   |       |   |--DOT -> . [49:18]
+    |       |   |   |       |   |   |--IDENT -> System [49:12]
+    |       |   |   |       |   |   `--IDENT -> out [49:19]
+    |       |   |   |       |   `--IDENT -> println [49:23]
+    |       |   |   |       |--ELIST -> ELIST [49:31]
+    |       |   |   |       `--RPAREN -> ) [49:31]
+    |       |   |   |--SEMI -> ; [49:32]
+    |       |   |   `--RCURLY -> } [50:8]
+    |       |   `--LITERAL_CATCH -> catch [51:8]
+    |       |       |--LPAREN -> ( [51:14]
+    |       |       |--PARAMETER_DEF -> PARAMETER_DEF [51:15]
+    |       |       |   |--MODIFIERS -> MODIFIERS [51:15]
+    |       |       |   |   `--ANNOTATION -> ANNOTATION [51:15]
+    |       |       |   |       |--AT -> @ [51:15]
+    |       |       |   |       `--IDENT -> NonNull [51:16]
+    |       |       |   |--TYPE -> TYPE [51:24]
+    |       |       |   |   |--IDENT -> IOError [51:24]
+    |       |       |   |   |--BOR -> | [51:32]
+    |       |       |   |   `--IDENT -> ArithmeticException [51:34]
+    |       |       |   `--IDENT -> e [51:54]
+    |       |       |--RPAREN -> ) [51:55]
+    |       |       `--SLIST -> { [51:57]
+    |       |           `--RCURLY -> } [53:8]
+    |       `--RCURLY -> } [54:4]
+    |--METHOD_DEF -> METHOD_DEF [56:4]
+    |   |--MODIFIERS -> MODIFIERS [56:4]
+    |   |--TYPE -> TYPE [56:4]
+    |   |   `--LITERAL_VOID -> void [56:4]
+    |   |--IDENT -> m23 [56:9]
+    |   |--LPAREN -> ( [56:12]
+    |   |--PARAMETERS -> PARAMETERS [56:13]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [56:13]
+    |   |       |--MODIFIERS -> MODIFIERS [56:13]
+    |   |       |--TYPE -> TYPE [56:13]
+    |   |       |   |--IDENT -> Class [56:13]
+    |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [56:18]
+    |   |       |       |--GENERIC_START -> < [56:18]
+    |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [56:19]
+    |   |       |       |   `--IDENT -> Object [56:19]
+    |   |       |       `--GENERIC_END -> > [56:25]
+    |   |       `--IDENT -> clazz [56:27]
+    |   |--RPAREN -> ) [56:32]
+    |   `--SLIST -> { [56:34]
+    |       |--LITERAL_IF -> if [57:8]
+    |       |   |--LPAREN -> ( [57:11]
+    |       |   |--EXPR -> EXPR [57:51]
+    |       |   |   `--NOT_EQUAL -> != [57:51]
+    |       |   |       |--DOT -> . [57:45]
+    |       |   |       |   |--IDENT -> InputAntlr4AstRegressionUncommon4 [57:12]
+    |       |   |       |   `--LITERAL_THIS -> this [57:46]
+    |       |   |       `--LITERAL_NULL -> null [57:54]
+    |       |   |--RPAREN -> ) [57:58]
+    |       |   `--SLIST -> { [57:60]
+    |       |       `--RCURLY -> } [58:8]
+    |       `--RCURLY -> } [59:4]
+    `--RCURLY -> } [61:0]
+CLASS_DEF -> CLASS_DEF [63:0]
+|--MODIFIERS -> MODIFIERS [63:0]
+|--LITERAL_CLASS -> class [63:0]
+|--IDENT -> H006_ComplexConstructors [63:6]
+|--TYPE_PARAMETERS -> TYPE_PARAMETERS [63:30]
+|   |--GENERIC_START -> < [63:30]
+|   |--TYPE_PARAMETER -> TYPE_PARAMETER [63:31]
+|   |   `--IDENT -> T [63:31]
+|   `--GENERIC_END -> > [63:32]
+`--OBJBLOCK -> OBJBLOCK [63:34]
+    |--LCURLY -> { [63:34]
+    |--CTOR_DEF -> CTOR_DEF [64:4]
+    |   |--MODIFIERS -> MODIFIERS [64:4]
+    |   |   `--LITERAL_PUBLIC -> public [64:4]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [64:11]
+    |   |   |--GENERIC_START -> < [64:11]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [64:12]
+    |   |   |   `--IDENT -> V [64:12]
+    |   |   `--GENERIC_END -> > [64:13]
+    |   |--IDENT -> H006_ComplexConstructors [64:15]
+    |   |--LPAREN -> ( [64:39]
+    |   |--PARAMETERS -> PARAMETERS [64:40]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [64:40]
+    |   |   |   |--MODIFIERS -> MODIFIERS [64:40]
+    |   |   |   |--TYPE -> TYPE [64:40]
+    |   |   |   |   `--IDENT -> T [64:40]
+    |   |   |   `--IDENT -> t [64:42]
+    |   |   |--COMMA -> , [64:43]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [64:45]
+    |   |       |--MODIFIERS -> MODIFIERS [64:45]
+    |   |       |--TYPE -> TYPE [64:45]
+    |   |       |   `--IDENT -> V [64:45]
+    |   |       `--IDENT -> v [64:47]
+    |   |--RPAREN -> ) [64:48]
+    |   `--SLIST -> { [64:50]
+    |       `--RCURLY -> } [65:4]
+    |--STATIC_INIT -> STATIC_INIT [67:4]
+    |   `--SLIST -> { [67:11]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [68:8]
+    |       |   |--MODIFIERS -> MODIFIERS [68:8]
+    |       |   |--TYPE -> TYPE [68:8]
+    |       |   |   |--IDENT -> H006_ComplexConstructors [68:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [68:32]
+    |       |   |       |--GENERIC_START -> < [68:32]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [68:33]
+    |       |   |       |   |--WILDCARD_TYPE -> ? [68:33]
+    |       |   |       |   `--TYPE_UPPER_BOUNDS -> extends [68:35]
+    |       |   |       |       `--IDENT -> Number [68:43]
+    |       |   |       `--GENERIC_END -> > [68:49]
+    |       |   |--IDENT -> x [68:51]
+    |       |   `--ASSIGN -> = [68:53]
+    |       |       `--EXPR -> EXPR [69:16]
+    |       |           `--LITERAL_NEW -> new [69:16]
+    |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [69:20]
+    |       |               |   |--GENERIC_START -> < [69:20]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [69:21]
+    |       |               |   |   `--IDENT -> String [69:21]
+    |       |               |   `--GENERIC_END -> > [69:27]
+    |       |               |--IDENT -> H006_ComplexConstructors [69:28]
+    |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [69:52]
+    |       |               |   |--GENERIC_START -> < [69:52]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [69:53]
+    |       |               |   |   `--IDENT -> Integer [69:53]
+    |       |               |   `--GENERIC_END -> > [69:60]
+    |       |               |--LPAREN -> ( [69:61]
+    |       |               |--ELIST -> ELIST [69:62]
+    |       |               |   |--EXPR -> EXPR [69:62]
+    |       |               |   |   `--NUM_INT -> 0 [69:62]
+    |       |               |   |--COMMA -> , [69:63]
+    |       |               |   `--EXPR -> EXPR [69:65]
+    |       |               |       `--STRING_LITERAL -> "" [69:65]
+    |       |               `--RPAREN -> ) [69:67]
+    |       |--SEMI -> ; [69:68]
+    |       `--RCURLY -> } [70:4]
+    |--CLASS_DEF -> CLASS_DEF [73:4]
+    |   |--MODIFIERS -> MODIFIERS [73:4]
+    |   |--LITERAL_CLASS -> class [73:4]
+    |   |--IDENT -> Inner3 [73:10]
+    |   `--OBJBLOCK -> OBJBLOCK [73:17]
+    |       |--LCURLY -> { [73:17]
+    |       |--CTOR_DEF -> CTOR_DEF [74:8]
+    |       |   |--MODIFIERS -> MODIFIERS [74:8]
+    |       |   |--IDENT -> Inner3 [74:8]
+    |       |   |--LPAREN -> ( [74:14]
+    |       |   |--PARAMETERS -> PARAMETERS [74:15]
+    |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [74:15]
+    |       |   |       |--MODIFIERS -> MODIFIERS [74:15]
+    |       |   |       |--TYPE -> TYPE [74:15]
+    |       |   |       |   `--LITERAL_INT -> int [74:15]
+    |       |   |       `--IDENT -> x [74:19]
+    |       |   |--RPAREN -> ) [74:20]
+    |       |   `--SLIST -> { [74:22]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [75:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [75:12]
+    |       |       |   |--TYPE -> TYPE [75:12]
+    |       |       |   |   |--IDENT -> H006_ComplexConstructors [75:12]
+    |       |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [75:36]
+    |       |       |   |       |--GENERIC_START -> < [75:36]
+    |       |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [75:37]
+    |       |       |   |       |   `--IDENT -> Integer [75:37]
+    |       |       |   |       `--GENERIC_END -> > [75:44]
+    |       |       |   |--IDENT -> instance [75:46]
+    |       |       |   `--ASSIGN -> = [75:55]
+    |       |       |       `--EXPR -> EXPR [76:20]
+    |       |       |           `--LITERAL_NEW -> new [76:20]
+    |       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [76:24]
+    |       |       |               |   |--GENERIC_START -> < [76:24]
+    |       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [76:25]
+    |       |       |               |   |   `--IDENT -> String [76:25]
+    |       |       |               |   `--GENERIC_END -> > [76:31]
+    |       |       |               |--IDENT -> H006_ComplexConstructors [76:32]
+    |       |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [76:56]
+    |       |       |               |   |--GENERIC_START -> < [76:56]
+    |       |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [76:57]
+    |       |       |               |   |   `--IDENT -> Integer [76:57]
+    |       |       |               |   `--GENERIC_END -> > [76:64]
+    |       |       |               |--LPAREN -> ( [76:65]
+    |       |       |               |--ELIST -> ELIST [76:66]
+    |       |       |               |   |--EXPR -> EXPR [76:66]
+    |       |       |               |   |   `--NUM_INT -> 0 [76:66]
+    |       |       |               |   |--COMMA -> , [76:67]
+    |       |       |               |   `--EXPR -> EXPR [76:69]
+    |       |       |               |       `--STRING_LITERAL -> "" [76:69]
+    |       |       |               `--RPAREN -> ) [76:71]
+    |       |       |--SEMI -> ; [76:72]
+    |       |       |--VARIABLE_DEF -> VARIABLE_DEF [77:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [77:12]
+    |       |       |   |--TYPE -> TYPE [77:12]
+    |       |       |   |   `--IDENT -> Object [77:12]
+    |       |       |   |--IDENT -> o [77:19]
+    |       |       |   `--ASSIGN -> = [77:21]
+    |       |       |       `--EXPR -> EXPR [77:45]
+    |       |       |           `--DOT -> . [77:45]
+    |       |       |               |--DOT -> . [77:31]
+    |       |       |               |   |--IDENT -> instance [77:23]
+    |       |       |               |   `--LITERAL_NEW -> new [77:32]
+    |       |       |               |       |--IDENT -> Inner3 [77:36]
+    |       |       |               |       |--LPAREN -> ( [77:42]
+    |       |       |               |       |--ELIST -> ELIST [77:43]
+    |       |       |               |       |   `--EXPR -> EXPR [77:43]
+    |       |       |               |       |       `--NUM_INT -> 5 [77:43]
+    |       |       |               |       `--RPAREN -> ) [77:44]
+    |       |       |               `--LITERAL_NEW -> new [77:46]
+    |       |       |                   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [77:50]
+    |       |       |                   |   |--GENERIC_START -> < [77:50]
+    |       |       |                   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [77:51]
+    |       |       |                   |   |   `--IDENT -> String [77:51]
+    |       |       |                   |   `--GENERIC_END -> > [77:57]
+    |       |       |                   |--IDENT -> InnerInner3 [77:58]
+    |       |       |                   |--LPAREN -> ( [77:69]
+    |       |       |                   |--ELIST -> ELIST [77:70]
+    |       |       |                   |   `--EXPR -> EXPR [77:70]
+    |       |       |                   |       `--STRING_LITERAL -> "hey" [77:70]
+    |       |       |                   `--RPAREN -> ) [77:75]
+    |       |       |--SEMI -> ; [77:76]
+    |       |       `--RCURLY -> } [78:8]
+    |       |--CLASS_DEF -> CLASS_DEF [80:8]
+    |       |   |--MODIFIERS -> MODIFIERS [80:8]
+    |       |   |--LITERAL_CLASS -> class [80:8]
+    |       |   |--IDENT -> InnerInner3 [80:14]
+    |       |   `--OBJBLOCK -> OBJBLOCK [80:26]
+    |       |       |--LCURLY -> { [80:26]
+    |       |       |--CTOR_DEF -> CTOR_DEF [81:12]
+    |       |       |   |--MODIFIERS -> MODIFIERS [81:12]
+    |       |       |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [81:12]
+    |       |       |   |   |--GENERIC_START -> < [81:12]
+    |       |       |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [81:13]
+    |       |       |   |   |   `--IDENT -> D [81:13]
+    |       |       |   |   `--GENERIC_END -> > [81:14]
+    |       |       |   |--IDENT -> InnerInner3 [81:16]
+    |       |       |   |--LPAREN -> ( [81:27]
+    |       |       |   |--PARAMETERS -> PARAMETERS [81:28]
+    |       |       |   |   `--PARAMETER_DEF -> PARAMETER_DEF [81:28]
+    |       |       |   |       |--MODIFIERS -> MODIFIERS [81:28]
+    |       |       |   |       |--TYPE -> TYPE [81:28]
+    |       |       |   |       |   `--IDENT -> D [81:28]
+    |       |       |   |       `--IDENT -> in [81:30]
+    |       |       |   |--RPAREN -> ) [81:32]
+    |       |       |   `--SLIST -> { [81:34]
+    |       |       |       `--RCURLY -> } [82:12]
+    |       |       `--RCURLY -> } [83:8]
+    |       `--RCURLY -> } [84:4]
+    `--RCURLY -> } [85:0]
+ANNOTATION_DEF -> ANNOTATION_DEF [87:0]
+|--MODIFIERS -> MODIFIERS [87:0]
+|--AT -> @ [87:0]
+|--LITERAL_INTERFACE -> interface [87:1]
+|--IDENT -> NonNull [87:11]
+`--OBJBLOCK -> OBJBLOCK [87:18]
+    |--LCURLY -> { [87:18]
+    `--RCURLY -> } [87:19]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionWeirdCtor.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionWeirdCtor.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionWeirdCtor.java
@@ -0,0 +1,93 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+
+public class InputAntlr4AstRegressionWeirdCtor {
+    void meth()
+    {
+        List<Integer> x = new ArrayList<Integer>();
+        List<List<Integer>> y = new ArrayList<List<Integer>>();
+        List < Integer > a = new ArrayList < Integer > ();
+        List < List < Integer > > b = new ArrayList < List < Integer > > ();
+    }
+    //always 0
+    public int compareTo(Object aObject)
+    {
+        return 0;
+    }
+
+    public static <T> Callable<T> callable(Runnable task, T result)
+    {
+        return null;
+    }
+
+    public static<T>Callable<T> callable2(Runnable task, T result)
+    {
+        Map<Class<?>, Integer> x = new HashMap<Class<?>, Integer>();
+        for (final Map.Entry<Class<?>, Integer> entry : x.entrySet()) {
+            entry.getValue();
+        }
+        Class<?>[] parameterClasses = new Class<?>[0];
+        return null;
+    }
+    public int getConstructor(Class<?>... parameterTypes)
+    {
+        Collections.<Object>emptySet();
+        Collections. <Object> emptySet();
+        return 666;
+    }
+
+    <T> InputAntlr4AstRegressionWeirdCtor(List<T> things, int i)
+    {
+    }
+
+    public <T> InputAntlr4AstRegressionWeirdCtor(List<T> things)
+    {
+    }
+
+    public interface IntEnum { /*inner enum*/
+    }
+
+    public static class IntEnumValueType<E extends Enum<E> & IntEnum> {
+    }
+
+    public static class IntEnumValueType2<E extends Enum<E>& IntEnum> {
+    }
+
+    public static class IntEnumValueType3<E extends Enum<E>  & IntEnum> {
+    }
+
+    public static class IntEnumValueType4<T extends Comparable<List<T>> & IntEnum> {
+    }
+
+    public void beforeAndAfter() {
+        List
+<
+Integer> x = new ArrayList<Integer
+>();
+        List
+                <Integer> y = new ArrayList<Integer
+        >();
+        Map<Class<?>, Integer> a = new HashMap<Class<?>, Integer>();
+        Map<Class<?>, Integer> b = (Map<Class<?>, Integer>) a;
+    }
+    Object ok = new <String>Object();
+    Object notOkStart = new<String>Object(); // violation
+    Object notOkEnd = new <String> Object(); // violation
+    Object notOkStartAndEnd = new<String> Object(); // violation
+    Object okWithPackage = new <String>java.lang.Object();
+    Object ok2 = new <String>Outer.Inner();
+    Object notOkStart2 = new<String>Outer.Inner(); // violation
+    Object notOkEnd2 = new <String> Outer.Inner(); // violation
+    Object notOkStartAndEnd2 = new<String> Outer.Inner(); // violation
+}
+interface SupplierFunction<T> extends Map<List<T>, T> {}
+
+class Outer {
+    static class Inner {}
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionWeirdCtor.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionWeirdCtor.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputAntlr4AstRegressionWeirdCtor.txt
@@ -0,0 +1,951 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+IMPORT -> import [3:0]
+|--DOT -> . [3:16]
+|   |--DOT -> . [3:11]
+|   |   |--IDENT -> java [3:7]
+|   |   `--IDENT -> util [3:12]
+|   `--IDENT -> ArrayList [3:17]
+`--SEMI -> ; [3:26]
+IMPORT -> import [4:0]
+|--DOT -> . [4:16]
+|   |--DOT -> . [4:11]
+|   |   |--IDENT -> java [4:7]
+|   |   `--IDENT -> util [4:12]
+|   `--IDENT -> Collections [4:17]
+`--SEMI -> ; [4:28]
+IMPORT -> import [5:0]
+|--DOT -> . [5:16]
+|   |--DOT -> . [5:11]
+|   |   |--IDENT -> java [5:7]
+|   |   `--IDENT -> util [5:12]
+|   `--IDENT -> HashMap [5:17]
+`--SEMI -> ; [5:24]
+IMPORT -> import [6:0]
+|--DOT -> . [6:16]
+|   |--DOT -> . [6:11]
+|   |   |--IDENT -> java [6:7]
+|   |   `--IDENT -> util [6:12]
+|   `--IDENT -> List [6:17]
+`--SEMI -> ; [6:21]
+IMPORT -> import [7:0]
+|--DOT -> . [7:16]
+|   |--DOT -> . [7:11]
+|   |   |--IDENT -> java [7:7]
+|   |   `--IDENT -> util [7:12]
+|   `--IDENT -> Map [7:17]
+`--SEMI -> ; [7:20]
+IMPORT -> import [8:0]
+|--DOT -> . [8:27]
+|   |--DOT -> . [8:16]
+|   |   |--DOT -> . [8:11]
+|   |   |   |--IDENT -> java [8:7]
+|   |   |   `--IDENT -> util [8:12]
+|   |   `--IDENT -> concurrent [8:17]
+|   `--IDENT -> Callable [8:28]
+`--SEMI -> ; [8:36]
+CLASS_DEF -> CLASS_DEF [10:0]
+|--MODIFIERS -> MODIFIERS [10:0]
+|   `--LITERAL_PUBLIC -> public [10:0]
+|--LITERAL_CLASS -> class [10:7]
+|--IDENT -> InputAntlr4AstRegressionWeirdCtor [10:13]
+`--OBJBLOCK -> OBJBLOCK [10:47]
+    |--LCURLY -> { [10:47]
+    |--METHOD_DEF -> METHOD_DEF [11:4]
+    |   |--MODIFIERS -> MODIFIERS [11:4]
+    |   |--TYPE -> TYPE [11:4]
+    |   |   `--LITERAL_VOID -> void [11:4]
+    |   |--IDENT -> meth [11:9]
+    |   |--LPAREN -> ( [11:13]
+    |   |--PARAMETERS -> PARAMETERS [11:14]
+    |   |--RPAREN -> ) [11:14]
+    |   `--SLIST -> { [12:4]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [13:8]
+    |       |   |--MODIFIERS -> MODIFIERS [13:8]
+    |       |   |--TYPE -> TYPE [13:8]
+    |       |   |   |--IDENT -> List [13:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [13:12]
+    |       |   |       |--GENERIC_START -> < [13:12]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [13:13]
+    |       |   |       |   `--IDENT -> Integer [13:13]
+    |       |   |       `--GENERIC_END -> > [13:20]
+    |       |   |--IDENT -> x [13:22]
+    |       |   `--ASSIGN -> = [13:24]
+    |       |       `--EXPR -> EXPR [13:26]
+    |       |           `--LITERAL_NEW -> new [13:26]
+    |       |               |--IDENT -> ArrayList [13:30]
+    |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [13:39]
+    |       |               |   |--GENERIC_START -> < [13:39]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [13:40]
+    |       |               |   |   `--IDENT -> Integer [13:40]
+    |       |               |   `--GENERIC_END -> > [13:47]
+    |       |               |--LPAREN -> ( [13:48]
+    |       |               |--ELIST -> ELIST [13:49]
+    |       |               `--RPAREN -> ) [13:49]
+    |       |--SEMI -> ; [13:50]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [14:8]
+    |       |   |--MODIFIERS -> MODIFIERS [14:8]
+    |       |   |--TYPE -> TYPE [14:8]
+    |       |   |   |--IDENT -> List [14:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [14:12]
+    |       |   |       |--GENERIC_START -> < [14:12]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [14:13]
+    |       |   |       |   |--IDENT -> List [14:13]
+    |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [14:17]
+    |       |   |       |       |--GENERIC_START -> < [14:17]
+    |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [14:18]
+    |       |   |       |       |   `--IDENT -> Integer [14:18]
+    |       |   |       |       `--GENERIC_END -> > [14:25]
+    |       |   |       `--GENERIC_END -> > [14:26]
+    |       |   |--IDENT -> y [14:28]
+    |       |   `--ASSIGN -> = [14:30]
+    |       |       `--EXPR -> EXPR [14:32]
+    |       |           `--LITERAL_NEW -> new [14:32]
+    |       |               |--IDENT -> ArrayList [14:36]
+    |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [14:45]
+    |       |               |   |--GENERIC_START -> < [14:45]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [14:46]
+    |       |               |   |   |--IDENT -> List [14:46]
+    |       |               |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [14:50]
+    |       |               |   |       |--GENERIC_START -> < [14:50]
+    |       |               |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [14:51]
+    |       |               |   |       |   `--IDENT -> Integer [14:51]
+    |       |               |   |       `--GENERIC_END -> > [14:58]
+    |       |               |   `--GENERIC_END -> > [14:59]
+    |       |               |--LPAREN -> ( [14:60]
+    |       |               |--ELIST -> ELIST [14:61]
+    |       |               `--RPAREN -> ) [14:61]
+    |       |--SEMI -> ; [14:62]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [15:8]
+    |       |   |--MODIFIERS -> MODIFIERS [15:8]
+    |       |   |--TYPE -> TYPE [15:8]
+    |       |   |   |--IDENT -> List [15:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [15:13]
+    |       |   |       |--GENERIC_START -> < [15:13]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [15:15]
+    |       |   |       |   `--IDENT -> Integer [15:15]
+    |       |   |       `--GENERIC_END -> > [15:23]
+    |       |   |--IDENT -> a [15:25]
+    |       |   `--ASSIGN -> = [15:27]
+    |       |       `--EXPR -> EXPR [15:29]
+    |       |           `--LITERAL_NEW -> new [15:29]
+    |       |               |--IDENT -> ArrayList [15:33]
+    |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [15:43]
+    |       |               |   |--GENERIC_START -> < [15:43]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [15:45]
+    |       |               |   |   `--IDENT -> Integer [15:45]
+    |       |               |   `--GENERIC_END -> > [15:53]
+    |       |               |--LPAREN -> ( [15:55]
+    |       |               |--ELIST -> ELIST [15:56]
+    |       |               `--RPAREN -> ) [15:56]
+    |       |--SEMI -> ; [15:57]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [16:8]
+    |       |   |--MODIFIERS -> MODIFIERS [16:8]
+    |       |   |--TYPE -> TYPE [16:8]
+    |       |   |   |--IDENT -> List [16:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [16:13]
+    |       |   |       |--GENERIC_START -> < [16:13]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [16:15]
+    |       |   |       |   |--IDENT -> List [16:15]
+    |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [16:20]
+    |       |   |       |       |--GENERIC_START -> < [16:20]
+    |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [16:22]
+    |       |   |       |       |   `--IDENT -> Integer [16:22]
+    |       |   |       |       `--GENERIC_END -> > [16:30]
+    |       |   |       `--GENERIC_END -> > [16:32]
+    |       |   |--IDENT -> b [16:34]
+    |       |   `--ASSIGN -> = [16:36]
+    |       |       `--EXPR -> EXPR [16:38]
+    |       |           `--LITERAL_NEW -> new [16:38]
+    |       |               |--IDENT -> ArrayList [16:42]
+    |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [16:52]
+    |       |               |   |--GENERIC_START -> < [16:52]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [16:54]
+    |       |               |   |   |--IDENT -> List [16:54]
+    |       |               |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [16:59]
+    |       |               |   |       |--GENERIC_START -> < [16:59]
+    |       |               |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [16:61]
+    |       |               |   |       |   `--IDENT -> Integer [16:61]
+    |       |               |   |       `--GENERIC_END -> > [16:69]
+    |       |               |   `--GENERIC_END -> > [16:71]
+    |       |               |--LPAREN -> ( [16:73]
+    |       |               |--ELIST -> ELIST [16:74]
+    |       |               `--RPAREN -> ) [16:74]
+    |       |--SEMI -> ; [16:75]
+    |       `--RCURLY -> } [17:4]
+    |--METHOD_DEF -> METHOD_DEF [19:4]
+    |   |--MODIFIERS -> MODIFIERS [19:4]
+    |   |   `--LITERAL_PUBLIC -> public [19:4]
+    |   |--TYPE -> TYPE [19:11]
+    |   |   `--LITERAL_INT -> int [19:11]
+    |   |--IDENT -> compareTo [19:15]
+    |   |--LPAREN -> ( [19:24]
+    |   |--PARAMETERS -> PARAMETERS [19:25]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [19:25]
+    |   |       |--MODIFIERS -> MODIFIERS [19:25]
+    |   |       |--TYPE -> TYPE [19:25]
+    |   |       |   `--IDENT -> Object [19:25]
+    |   |       `--IDENT -> aObject [19:32]
+    |   |--RPAREN -> ) [19:39]
+    |   `--SLIST -> { [20:4]
+    |       |--LITERAL_RETURN -> return [21:8]
+    |       |   |--EXPR -> EXPR [21:15]
+    |       |   |   `--NUM_INT -> 0 [21:15]
+    |       |   `--SEMI -> ; [21:16]
+    |       `--RCURLY -> } [22:4]
+    |--METHOD_DEF -> METHOD_DEF [24:4]
+    |   |--MODIFIERS -> MODIFIERS [24:4]
+    |   |   |--LITERAL_PUBLIC -> public [24:4]
+    |   |   `--LITERAL_STATIC -> static [24:11]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [24:18]
+    |   |   |--GENERIC_START -> < [24:18]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [24:19]
+    |   |   |   `--IDENT -> T [24:19]
+    |   |   `--GENERIC_END -> > [24:20]
+    |   |--TYPE -> TYPE [24:22]
+    |   |   |--IDENT -> Callable [24:22]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [24:30]
+    |   |       |--GENERIC_START -> < [24:30]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [24:31]
+    |   |       |   `--IDENT -> T [24:31]
+    |   |       `--GENERIC_END -> > [24:32]
+    |   |--IDENT -> callable [24:34]
+    |   |--LPAREN -> ( [24:42]
+    |   |--PARAMETERS -> PARAMETERS [24:43]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [24:43]
+    |   |   |   |--MODIFIERS -> MODIFIERS [24:43]
+    |   |   |   |--TYPE -> TYPE [24:43]
+    |   |   |   |   `--IDENT -> Runnable [24:43]
+    |   |   |   `--IDENT -> task [24:52]
+    |   |   |--COMMA -> , [24:56]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [24:58]
+    |   |       |--MODIFIERS -> MODIFIERS [24:58]
+    |   |       |--TYPE -> TYPE [24:58]
+    |   |       |   `--IDENT -> T [24:58]
+    |   |       `--IDENT -> result [24:60]
+    |   |--RPAREN -> ) [24:66]
+    |   `--SLIST -> { [25:4]
+    |       |--LITERAL_RETURN -> return [26:8]
+    |       |   |--EXPR -> EXPR [26:15]
+    |       |   |   `--LITERAL_NULL -> null [26:15]
+    |       |   `--SEMI -> ; [26:19]
+    |       `--RCURLY -> } [27:4]
+    |--METHOD_DEF -> METHOD_DEF [29:4]
+    |   |--MODIFIERS -> MODIFIERS [29:4]
+    |   |   |--LITERAL_PUBLIC -> public [29:4]
+    |   |   `--LITERAL_STATIC -> static [29:11]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [29:17]
+    |   |   |--GENERIC_START -> < [29:17]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [29:18]
+    |   |   |   `--IDENT -> T [29:18]
+    |   |   `--GENERIC_END -> > [29:19]
+    |   |--TYPE -> TYPE [29:20]
+    |   |   |--IDENT -> Callable [29:20]
+    |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [29:28]
+    |   |       |--GENERIC_START -> < [29:28]
+    |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [29:29]
+    |   |       |   `--IDENT -> T [29:29]
+    |   |       `--GENERIC_END -> > [29:30]
+    |   |--IDENT -> callable2 [29:32]
+    |   |--LPAREN -> ( [29:41]
+    |   |--PARAMETERS -> PARAMETERS [29:42]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [29:42]
+    |   |   |   |--MODIFIERS -> MODIFIERS [29:42]
+    |   |   |   |--TYPE -> TYPE [29:42]
+    |   |   |   |   `--IDENT -> Runnable [29:42]
+    |   |   |   `--IDENT -> task [29:51]
+    |   |   |--COMMA -> , [29:55]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [29:57]
+    |   |       |--MODIFIERS -> MODIFIERS [29:57]
+    |   |       |--TYPE -> TYPE [29:57]
+    |   |       |   `--IDENT -> T [29:57]
+    |   |       `--IDENT -> result [29:59]
+    |   |--RPAREN -> ) [29:65]
+    |   `--SLIST -> { [30:4]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [31:8]
+    |       |   |--MODIFIERS -> MODIFIERS [31:8]
+    |       |   |--TYPE -> TYPE [31:8]
+    |       |   |   |--IDENT -> Map [31:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:11]
+    |       |   |       |--GENERIC_START -> < [31:11]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:12]
+    |       |   |       |   |--IDENT -> Class [31:12]
+    |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:17]
+    |       |   |       |       |--GENERIC_START -> < [31:17]
+    |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:18]
+    |       |   |       |       |   `--WILDCARD_TYPE -> ? [31:18]
+    |       |   |       |       `--GENERIC_END -> > [31:19]
+    |       |   |       |--COMMA -> , [31:20]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:22]
+    |       |   |       |   `--IDENT -> Integer [31:22]
+    |       |   |       `--GENERIC_END -> > [31:29]
+    |       |   |--IDENT -> x [31:31]
+    |       |   `--ASSIGN -> = [31:33]
+    |       |       `--EXPR -> EXPR [31:35]
+    |       |           `--LITERAL_NEW -> new [31:35]
+    |       |               |--IDENT -> HashMap [31:39]
+    |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:46]
+    |       |               |   |--GENERIC_START -> < [31:46]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:47]
+    |       |               |   |   |--IDENT -> Class [31:47]
+    |       |               |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [31:52]
+    |       |               |   |       |--GENERIC_START -> < [31:52]
+    |       |               |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:53]
+    |       |               |   |       |   `--WILDCARD_TYPE -> ? [31:53]
+    |       |               |   |       `--GENERIC_END -> > [31:54]
+    |       |               |   |--COMMA -> , [31:55]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [31:57]
+    |       |               |   |   `--IDENT -> Integer [31:57]
+    |       |               |   `--GENERIC_END -> > [31:64]
+    |       |               |--LPAREN -> ( [31:65]
+    |       |               |--ELIST -> ELIST [31:66]
+    |       |               `--RPAREN -> ) [31:66]
+    |       |--SEMI -> ; [31:67]
+    |       |--LITERAL_FOR -> for [32:8]
+    |       |   |--LPAREN -> ( [32:12]
+    |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [32:13]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [32:13]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [32:13]
+    |       |   |   |   |   `--FINAL -> final [32:13]
+    |       |   |   |   |--TYPE -> TYPE [32:22]
+    |       |   |   |   |   `--DOT -> . [32:22]
+    |       |   |   |   |       |--IDENT -> Map [32:19]
+    |       |   |   |   |       |--IDENT -> Entry [32:23]
+    |       |   |   |   |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [32:28]
+    |       |   |   |   |           |--GENERIC_START -> < [32:28]
+    |       |   |   |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [32:29]
+    |       |   |   |   |           |   |--IDENT -> Class [32:29]
+    |       |   |   |   |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [32:34]
+    |       |   |   |   |           |       |--GENERIC_START -> < [32:34]
+    |       |   |   |   |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [32:35]
+    |       |   |   |   |           |       |   `--WILDCARD_TYPE -> ? [32:35]
+    |       |   |   |   |           |       `--GENERIC_END -> > [32:36]
+    |       |   |   |   |           |--COMMA -> , [32:37]
+    |       |   |   |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [32:39]
+    |       |   |   |   |           |   `--IDENT -> Integer [32:39]
+    |       |   |   |   |           `--GENERIC_END -> > [32:46]
+    |       |   |   |   `--IDENT -> entry [32:48]
+    |       |   |   |--COLON -> : [32:54]
+    |       |   |   `--EXPR -> EXPR [32:66]
+    |       |   |       `--METHOD_CALL -> ( [32:66]
+    |       |   |           |--DOT -> . [32:57]
+    |       |   |           |   |--IDENT -> x [32:56]
+    |       |   |           |   `--IDENT -> entrySet [32:58]
+    |       |   |           |--ELIST -> ELIST [32:67]
+    |       |   |           `--RPAREN -> ) [32:67]
+    |       |   |--RPAREN -> ) [32:68]
+    |       |   `--SLIST -> { [32:70]
+    |       |       |--EXPR -> EXPR [33:26]
+    |       |       |   `--METHOD_CALL -> ( [33:26]
+    |       |       |       |--DOT -> . [33:17]
+    |       |       |       |   |--IDENT -> entry [33:12]
+    |       |       |       |   `--IDENT -> getValue [33:18]
+    |       |       |       |--ELIST -> ELIST [33:27]
+    |       |       |       `--RPAREN -> ) [33:27]
+    |       |       |--SEMI -> ; [33:28]
+    |       |       `--RCURLY -> } [34:8]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [35:8]
+    |       |   |--MODIFIERS -> MODIFIERS [35:8]
+    |       |   |--TYPE -> TYPE [35:8]
+    |       |   |   |--IDENT -> Class [35:8]
+    |       |   |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [35:13]
+    |       |   |   |   |--GENERIC_START -> < [35:13]
+    |       |   |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [35:14]
+    |       |   |   |   |   `--WILDCARD_TYPE -> ? [35:14]
+    |       |   |   |   `--GENERIC_END -> > [35:15]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [35:16]
+    |       |   |       `--RBRACK -> ] [35:17]
+    |       |   |--IDENT -> parameterClasses [35:19]
+    |       |   `--ASSIGN -> = [35:36]
+    |       |       `--EXPR -> EXPR [35:38]
+    |       |           `--LITERAL_NEW -> new [35:38]
+    |       |               |--IDENT -> Class [35:42]
+    |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [35:47]
+    |       |               |   |--GENERIC_START -> < [35:47]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [35:48]
+    |       |               |   |   `--WILDCARD_TYPE -> ? [35:48]
+    |       |               |   `--GENERIC_END -> > [35:49]
+    |       |               `--ARRAY_DECLARATOR -> [ [35:50]
+    |       |                   |--EXPR -> EXPR [35:51]
+    |       |                   |   `--NUM_INT -> 0 [35:51]
+    |       |                   `--RBRACK -> ] [35:52]
+    |       |--SEMI -> ; [35:53]
+    |       |--LITERAL_RETURN -> return [36:8]
+    |       |   |--EXPR -> EXPR [36:15]
+    |       |   |   `--LITERAL_NULL -> null [36:15]
+    |       |   `--SEMI -> ; [36:19]
+    |       `--RCURLY -> } [37:4]
+    |--METHOD_DEF -> METHOD_DEF [38:4]
+    |   |--MODIFIERS -> MODIFIERS [38:4]
+    |   |   `--LITERAL_PUBLIC -> public [38:4]
+    |   |--TYPE -> TYPE [38:11]
+    |   |   `--LITERAL_INT -> int [38:11]
+    |   |--IDENT -> getConstructor [38:15]
+    |   |--LPAREN -> ( [38:29]
+    |   |--PARAMETERS -> PARAMETERS [38:30]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [38:30]
+    |   |       |--MODIFIERS -> MODIFIERS [38:30]
+    |   |       |--TYPE -> TYPE [38:30]
+    |   |       |   |--IDENT -> Class [38:30]
+    |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [38:35]
+    |   |       |       |--GENERIC_START -> < [38:35]
+    |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [38:36]
+    |   |       |       |   `--WILDCARD_TYPE -> ? [38:36]
+    |   |       |       `--GENERIC_END -> > [38:37]
+    |   |       |--ELLIPSIS -> ... [38:38]
+    |   |       `--IDENT -> parameterTypes [38:42]
+    |   |--RPAREN -> ) [38:56]
+    |   `--SLIST -> { [39:4]
+    |       |--EXPR -> EXPR [40:36]
+    |       |   `--METHOD_CALL -> ( [40:36]
+    |       |       |--DOT -> . [40:19]
+    |       |       |   |--IDENT -> Collections [40:8]
+    |       |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [40:20]
+    |       |       |   |   |--GENERIC_START -> < [40:20]
+    |       |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [40:21]
+    |       |       |   |   |   `--IDENT -> Object [40:21]
+    |       |       |   |   `--GENERIC_END -> > [40:27]
+    |       |       |   `--IDENT -> emptySet [40:28]
+    |       |       |--ELIST -> ELIST [40:37]
+    |       |       `--RPAREN -> ) [40:37]
+    |       |--SEMI -> ; [40:38]
+    |       |--EXPR -> EXPR [41:38]
+    |       |   `--METHOD_CALL -> ( [41:38]
+    |       |       |--DOT -> . [41:19]
+    |       |       |   |--IDENT -> Collections [41:8]
+    |       |       |   |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [41:21]
+    |       |       |   |   |--GENERIC_START -> < [41:21]
+    |       |       |   |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [41:22]
+    |       |       |   |   |   `--IDENT -> Object [41:22]
+    |       |       |   |   `--GENERIC_END -> > [41:28]
+    |       |       |   `--IDENT -> emptySet [41:30]
+    |       |       |--ELIST -> ELIST [41:39]
+    |       |       `--RPAREN -> ) [41:39]
+    |       |--SEMI -> ; [41:40]
+    |       |--LITERAL_RETURN -> return [42:8]
+    |       |   |--EXPR -> EXPR [42:15]
+    |       |   |   `--NUM_INT -> 666 [42:15]
+    |       |   `--SEMI -> ; [42:18]
+    |       `--RCURLY -> } [43:4]
+    |--CTOR_DEF -> CTOR_DEF [45:4]
+    |   |--MODIFIERS -> MODIFIERS [45:4]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [45:4]
+    |   |   |--GENERIC_START -> < [45:4]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [45:5]
+    |   |   |   `--IDENT -> T [45:5]
+    |   |   `--GENERIC_END -> > [45:6]
+    |   |--IDENT -> InputAntlr4AstRegressionWeirdCtor [45:8]
+    |   |--LPAREN -> ( [45:41]
+    |   |--PARAMETERS -> PARAMETERS [45:42]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [45:42]
+    |   |   |   |--MODIFIERS -> MODIFIERS [45:42]
+    |   |   |   |--TYPE -> TYPE [45:42]
+    |   |   |   |   |--IDENT -> List [45:42]
+    |   |   |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [45:46]
+    |   |   |   |       |--GENERIC_START -> < [45:46]
+    |   |   |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [45:47]
+    |   |   |   |       |   `--IDENT -> T [45:47]
+    |   |   |   |       `--GENERIC_END -> > [45:48]
+    |   |   |   `--IDENT -> things [45:50]
+    |   |   |--COMMA -> , [45:56]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [45:58]
+    |   |       |--MODIFIERS -> MODIFIERS [45:58]
+    |   |       |--TYPE -> TYPE [45:58]
+    |   |       |   `--LITERAL_INT -> int [45:58]
+    |   |       `--IDENT -> i [45:62]
+    |   |--RPAREN -> ) [45:63]
+    |   `--SLIST -> { [46:4]
+    |       `--RCURLY -> } [47:4]
+    |--CTOR_DEF -> CTOR_DEF [49:4]
+    |   |--MODIFIERS -> MODIFIERS [49:4]
+    |   |   `--LITERAL_PUBLIC -> public [49:4]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [49:11]
+    |   |   |--GENERIC_START -> < [49:11]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [49:12]
+    |   |   |   `--IDENT -> T [49:12]
+    |   |   `--GENERIC_END -> > [49:13]
+    |   |--IDENT -> InputAntlr4AstRegressionWeirdCtor [49:15]
+    |   |--LPAREN -> ( [49:48]
+    |   |--PARAMETERS -> PARAMETERS [49:49]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [49:49]
+    |   |       |--MODIFIERS -> MODIFIERS [49:49]
+    |   |       |--TYPE -> TYPE [49:49]
+    |   |       |   |--IDENT -> List [49:49]
+    |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [49:53]
+    |   |       |       |--GENERIC_START -> < [49:53]
+    |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [49:54]
+    |   |       |       |   `--IDENT -> T [49:54]
+    |   |       |       `--GENERIC_END -> > [49:55]
+    |   |       `--IDENT -> things [49:57]
+    |   |--RPAREN -> ) [49:63]
+    |   `--SLIST -> { [50:4]
+    |       `--RCURLY -> } [51:4]
+    |--INTERFACE_DEF -> INTERFACE_DEF [53:4]
+    |   |--MODIFIERS -> MODIFIERS [53:4]
+    |   |   `--LITERAL_PUBLIC -> public [53:4]
+    |   |--LITERAL_INTERFACE -> interface [53:11]
+    |   |--IDENT -> IntEnum [53:21]
+    |   `--OBJBLOCK -> OBJBLOCK [53:29]
+    |       |--LCURLY -> { [53:29]
+    |       `--RCURLY -> } [54:4]
+    |--CLASS_DEF -> CLASS_DEF [56:4]
+    |   |--MODIFIERS -> MODIFIERS [56:4]
+    |   |   |--LITERAL_PUBLIC -> public [56:4]
+    |   |   `--LITERAL_STATIC -> static [56:11]
+    |   |--LITERAL_CLASS -> class [56:18]
+    |   |--IDENT -> IntEnumValueType [56:24]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [56:40]
+    |   |   |--GENERIC_START -> < [56:40]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [56:41]
+    |   |   |   |--IDENT -> E [56:41]
+    |   |   |   `--TYPE_UPPER_BOUNDS -> extends [56:43]
+    |   |   |       |--IDENT -> Enum [56:51]
+    |   |   |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [56:55]
+    |   |   |       |   |--GENERIC_START -> < [56:55]
+    |   |   |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [56:56]
+    |   |   |       |   |   `--IDENT -> E [56:56]
+    |   |   |       |   `--GENERIC_END -> > [56:57]
+    |   |   |       |--TYPE_EXTENSION_AND -> & [56:59]
+    |   |   |       `--IDENT -> IntEnum [56:61]
+    |   |   `--GENERIC_END -> > [56:68]
+    |   `--OBJBLOCK -> OBJBLOCK [56:70]
+    |       |--LCURLY -> { [56:70]
+    |       `--RCURLY -> } [57:4]
+    |--CLASS_DEF -> CLASS_DEF [59:4]
+    |   |--MODIFIERS -> MODIFIERS [59:4]
+    |   |   |--LITERAL_PUBLIC -> public [59:4]
+    |   |   `--LITERAL_STATIC -> static [59:11]
+    |   |--LITERAL_CLASS -> class [59:18]
+    |   |--IDENT -> IntEnumValueType2 [59:24]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [59:41]
+    |   |   |--GENERIC_START -> < [59:41]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [59:42]
+    |   |   |   |--IDENT -> E [59:42]
+    |   |   |   `--TYPE_UPPER_BOUNDS -> extends [59:44]
+    |   |   |       |--IDENT -> Enum [59:52]
+    |   |   |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [59:56]
+    |   |   |       |   |--GENERIC_START -> < [59:56]
+    |   |   |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [59:57]
+    |   |   |       |   |   `--IDENT -> E [59:57]
+    |   |   |       |   `--GENERIC_END -> > [59:58]
+    |   |   |       |--TYPE_EXTENSION_AND -> & [59:59]
+    |   |   |       `--IDENT -> IntEnum [59:61]
+    |   |   `--GENERIC_END -> > [59:68]
+    |   `--OBJBLOCK -> OBJBLOCK [59:70]
+    |       |--LCURLY -> { [59:70]
+    |       `--RCURLY -> } [60:4]
+    |--CLASS_DEF -> CLASS_DEF [62:4]
+    |   |--MODIFIERS -> MODIFIERS [62:4]
+    |   |   |--LITERAL_PUBLIC -> public [62:4]
+    |   |   `--LITERAL_STATIC -> static [62:11]
+    |   |--LITERAL_CLASS -> class [62:18]
+    |   |--IDENT -> IntEnumValueType3 [62:24]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [62:41]
+    |   |   |--GENERIC_START -> < [62:41]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [62:42]
+    |   |   |   |--IDENT -> E [62:42]
+    |   |   |   `--TYPE_UPPER_BOUNDS -> extends [62:44]
+    |   |   |       |--IDENT -> Enum [62:52]
+    |   |   |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [62:56]
+    |   |   |       |   |--GENERIC_START -> < [62:56]
+    |   |   |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [62:57]
+    |   |   |       |   |   `--IDENT -> E [62:57]
+    |   |   |       |   `--GENERIC_END -> > [62:58]
+    |   |   |       |--TYPE_EXTENSION_AND -> & [62:61]
+    |   |   |       `--IDENT -> IntEnum [62:63]
+    |   |   `--GENERIC_END -> > [62:70]
+    |   `--OBJBLOCK -> OBJBLOCK [62:72]
+    |       |--LCURLY -> { [62:72]
+    |       `--RCURLY -> } [63:4]
+    |--CLASS_DEF -> CLASS_DEF [65:4]
+    |   |--MODIFIERS -> MODIFIERS [65:4]
+    |   |   |--LITERAL_PUBLIC -> public [65:4]
+    |   |   `--LITERAL_STATIC -> static [65:11]
+    |   |--LITERAL_CLASS -> class [65:18]
+    |   |--IDENT -> IntEnumValueType4 [65:24]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [65:41]
+    |   |   |--GENERIC_START -> < [65:41]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [65:42]
+    |   |   |   |--IDENT -> T [65:42]
+    |   |   |   `--TYPE_UPPER_BOUNDS -> extends [65:44]
+    |   |   |       |--IDENT -> Comparable [65:52]
+    |   |   |       |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [65:62]
+    |   |   |       |   |--GENERIC_START -> < [65:62]
+    |   |   |       |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [65:63]
+    |   |   |       |   |   |--IDENT -> List [65:63]
+    |   |   |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [65:67]
+    |   |   |       |   |       |--GENERIC_START -> < [65:67]
+    |   |   |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [65:68]
+    |   |   |       |   |       |   `--IDENT -> T [65:68]
+    |   |   |       |   |       `--GENERIC_END -> > [65:69]
+    |   |   |       |   `--GENERIC_END -> > [65:70]
+    |   |   |       |--TYPE_EXTENSION_AND -> & [65:72]
+    |   |   |       `--IDENT -> IntEnum [65:74]
+    |   |   `--GENERIC_END -> > [65:81]
+    |   `--OBJBLOCK -> OBJBLOCK [65:83]
+    |       |--LCURLY -> { [65:83]
+    |       `--RCURLY -> } [66:4]
+    |--METHOD_DEF -> METHOD_DEF [68:4]
+    |   |--MODIFIERS -> MODIFIERS [68:4]
+    |   |   `--LITERAL_PUBLIC -> public [68:4]
+    |   |--TYPE -> TYPE [68:11]
+    |   |   `--LITERAL_VOID -> void [68:11]
+    |   |--IDENT -> beforeAndAfter [68:16]
+    |   |--LPAREN -> ( [68:30]
+    |   |--PARAMETERS -> PARAMETERS [68:31]
+    |   |--RPAREN -> ) [68:31]
+    |   `--SLIST -> { [68:33]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [69:8]
+    |       |   |--MODIFIERS -> MODIFIERS [69:8]
+    |       |   |--TYPE -> TYPE [69:8]
+    |       |   |   |--IDENT -> List [69:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [70:0]
+    |       |   |       |--GENERIC_START -> < [70:0]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [71:0]
+    |       |   |       |   `--IDENT -> Integer [71:0]
+    |       |   |       `--GENERIC_END -> > [71:7]
+    |       |   |--IDENT -> x [71:9]
+    |       |   `--ASSIGN -> = [71:11]
+    |       |       `--EXPR -> EXPR [71:13]
+    |       |           `--LITERAL_NEW -> new [71:13]
+    |       |               |--IDENT -> ArrayList [71:17]
+    |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [71:26]
+    |       |               |   |--GENERIC_START -> < [71:26]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [71:27]
+    |       |               |   |   `--IDENT -> Integer [71:27]
+    |       |               |   `--GENERIC_END -> > [72:0]
+    |       |               |--LPAREN -> ( [72:1]
+    |       |               |--ELIST -> ELIST [72:2]
+    |       |               `--RPAREN -> ) [72:2]
+    |       |--SEMI -> ; [72:3]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [73:8]
+    |       |   |--MODIFIERS -> MODIFIERS [73:8]
+    |       |   |--TYPE -> TYPE [73:8]
+    |       |   |   |--IDENT -> List [73:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [74:16]
+    |       |   |       |--GENERIC_START -> < [74:16]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [74:17]
+    |       |   |       |   `--IDENT -> Integer [74:17]
+    |       |   |       `--GENERIC_END -> > [74:24]
+    |       |   |--IDENT -> y [74:26]
+    |       |   `--ASSIGN -> = [74:28]
+    |       |       `--EXPR -> EXPR [74:30]
+    |       |           `--LITERAL_NEW -> new [74:30]
+    |       |               |--IDENT -> ArrayList [74:34]
+    |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [74:43]
+    |       |               |   |--GENERIC_START -> < [74:43]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [74:44]
+    |       |               |   |   `--IDENT -> Integer [74:44]
+    |       |               |   `--GENERIC_END -> > [75:8]
+    |       |               |--LPAREN -> ( [75:9]
+    |       |               |--ELIST -> ELIST [75:10]
+    |       |               `--RPAREN -> ) [75:10]
+    |       |--SEMI -> ; [75:11]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [76:8]
+    |       |   |--MODIFIERS -> MODIFIERS [76:8]
+    |       |   |--TYPE -> TYPE [76:8]
+    |       |   |   |--IDENT -> Map [76:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [76:11]
+    |       |   |       |--GENERIC_START -> < [76:11]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [76:12]
+    |       |   |       |   |--IDENT -> Class [76:12]
+    |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [76:17]
+    |       |   |       |       |--GENERIC_START -> < [76:17]
+    |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [76:18]
+    |       |   |       |       |   `--WILDCARD_TYPE -> ? [76:18]
+    |       |   |       |       `--GENERIC_END -> > [76:19]
+    |       |   |       |--COMMA -> , [76:20]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [76:22]
+    |       |   |       |   `--IDENT -> Integer [76:22]
+    |       |   |       `--GENERIC_END -> > [76:29]
+    |       |   |--IDENT -> a [76:31]
+    |       |   `--ASSIGN -> = [76:33]
+    |       |       `--EXPR -> EXPR [76:35]
+    |       |           `--LITERAL_NEW -> new [76:35]
+    |       |               |--IDENT -> HashMap [76:39]
+    |       |               |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [76:46]
+    |       |               |   |--GENERIC_START -> < [76:46]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [76:47]
+    |       |               |   |   |--IDENT -> Class [76:47]
+    |       |               |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [76:52]
+    |       |               |   |       |--GENERIC_START -> < [76:52]
+    |       |               |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [76:53]
+    |       |               |   |       |   `--WILDCARD_TYPE -> ? [76:53]
+    |       |               |   |       `--GENERIC_END -> > [76:54]
+    |       |               |   |--COMMA -> , [76:55]
+    |       |               |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [76:57]
+    |       |               |   |   `--IDENT -> Integer [76:57]
+    |       |               |   `--GENERIC_END -> > [76:64]
+    |       |               |--LPAREN -> ( [76:65]
+    |       |               |--ELIST -> ELIST [76:66]
+    |       |               `--RPAREN -> ) [76:66]
+    |       |--SEMI -> ; [76:67]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [77:8]
+    |       |   |--MODIFIERS -> MODIFIERS [77:8]
+    |       |   |--TYPE -> TYPE [77:8]
+    |       |   |   |--IDENT -> Map [77:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [77:11]
+    |       |   |       |--GENERIC_START -> < [77:11]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [77:12]
+    |       |   |       |   |--IDENT -> Class [77:12]
+    |       |   |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [77:17]
+    |       |   |       |       |--GENERIC_START -> < [77:17]
+    |       |   |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [77:18]
+    |       |   |       |       |   `--WILDCARD_TYPE -> ? [77:18]
+    |       |   |       |       `--GENERIC_END -> > [77:19]
+    |       |   |       |--COMMA -> , [77:20]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [77:22]
+    |       |   |       |   `--IDENT -> Integer [77:22]
+    |       |   |       `--GENERIC_END -> > [77:29]
+    |       |   |--IDENT -> b [77:31]
+    |       |   `--ASSIGN -> = [77:33]
+    |       |       `--EXPR -> EXPR [77:35]
+    |       |           `--TYPECAST -> ( [77:35]
+    |       |               |--TYPE -> TYPE [77:36]
+    |       |               |   |--IDENT -> Map [77:36]
+    |       |               |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [77:39]
+    |       |               |       |--GENERIC_START -> < [77:39]
+    |       |               |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [77:40]
+    |       |               |       |   |--IDENT -> Class [77:40]
+    |       |               |       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [77:45]
+    |       |               |       |       |--GENERIC_START -> < [77:45]
+    |       |               |       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [77:46]
+    |       |               |       |       |   `--WILDCARD_TYPE -> ? [77:46]
+    |       |               |       |       `--GENERIC_END -> > [77:47]
+    |       |               |       |--COMMA -> , [77:48]
+    |       |               |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [77:50]
+    |       |               |       |   `--IDENT -> Integer [77:50]
+    |       |               |       `--GENERIC_END -> > [77:57]
+    |       |               |--RPAREN -> ) [77:58]
+    |       |               `--IDENT -> a [77:60]
+    |       |--SEMI -> ; [77:61]
+    |       `--RCURLY -> } [78:4]
+    |--VARIABLE_DEF -> VARIABLE_DEF [79:4]
+    |   |--MODIFIERS -> MODIFIERS [79:4]
+    |   |--TYPE -> TYPE [79:4]
+    |   |   `--IDENT -> Object [79:4]
+    |   |--IDENT -> ok [79:11]
+    |   |--ASSIGN -> = [79:14]
+    |   |   `--EXPR -> EXPR [79:16]
+    |   |       `--LITERAL_NEW -> new [79:16]
+    |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [79:20]
+    |   |           |   |--GENERIC_START -> < [79:20]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [79:21]
+    |   |           |   |   `--IDENT -> String [79:21]
+    |   |           |   `--GENERIC_END -> > [79:27]
+    |   |           |--IDENT -> Object [79:28]
+    |   |           |--LPAREN -> ( [79:34]
+    |   |           |--ELIST -> ELIST [79:35]
+    |   |           `--RPAREN -> ) [79:35]
+    |   `--SEMI -> ; [79:36]
+    |--VARIABLE_DEF -> VARIABLE_DEF [80:4]
+    |   |--MODIFIERS -> MODIFIERS [80:4]
+    |   |--TYPE -> TYPE [80:4]
+    |   |   `--IDENT -> Object [80:4]
+    |   |--IDENT -> notOkStart [80:11]
+    |   |--ASSIGN -> = [80:22]
+    |   |   `--EXPR -> EXPR [80:24]
+    |   |       `--LITERAL_NEW -> new [80:24]
+    |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [80:27]
+    |   |           |   |--GENERIC_START -> < [80:27]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [80:28]
+    |   |           |   |   `--IDENT -> String [80:28]
+    |   |           |   `--GENERIC_END -> > [80:34]
+    |   |           |--IDENT -> Object [80:35]
+    |   |           |--LPAREN -> ( [80:41]
+    |   |           |--ELIST -> ELIST [80:42]
+    |   |           `--RPAREN -> ) [80:42]
+    |   `--SEMI -> ; [80:43]
+    |--VARIABLE_DEF -> VARIABLE_DEF [81:4]
+    |   |--MODIFIERS -> MODIFIERS [81:4]
+    |   |--TYPE -> TYPE [81:4]
+    |   |   `--IDENT -> Object [81:4]
+    |   |--IDENT -> notOkEnd [81:11]
+    |   |--ASSIGN -> = [81:20]
+    |   |   `--EXPR -> EXPR [81:22]
+    |   |       `--LITERAL_NEW -> new [81:22]
+    |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [81:26]
+    |   |           |   |--GENERIC_START -> < [81:26]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [81:27]
+    |   |           |   |   `--IDENT -> String [81:27]
+    |   |           |   `--GENERIC_END -> > [81:33]
+    |   |           |--IDENT -> Object [81:35]
+    |   |           |--LPAREN -> ( [81:41]
+    |   |           |--ELIST -> ELIST [81:42]
+    |   |           `--RPAREN -> ) [81:42]
+    |   `--SEMI -> ; [81:43]
+    |--VARIABLE_DEF -> VARIABLE_DEF [82:4]
+    |   |--MODIFIERS -> MODIFIERS [82:4]
+    |   |--TYPE -> TYPE [82:4]
+    |   |   `--IDENT -> Object [82:4]
+    |   |--IDENT -> notOkStartAndEnd [82:11]
+    |   |--ASSIGN -> = [82:28]
+    |   |   `--EXPR -> EXPR [82:30]
+    |   |       `--LITERAL_NEW -> new [82:30]
+    |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [82:33]
+    |   |           |   |--GENERIC_START -> < [82:33]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [82:34]
+    |   |           |   |   `--IDENT -> String [82:34]
+    |   |           |   `--GENERIC_END -> > [82:40]
+    |   |           |--IDENT -> Object [82:42]
+    |   |           |--LPAREN -> ( [82:48]
+    |   |           |--ELIST -> ELIST [82:49]
+    |   |           `--RPAREN -> ) [82:49]
+    |   `--SEMI -> ; [82:50]
+    |--VARIABLE_DEF -> VARIABLE_DEF [83:4]
+    |   |--MODIFIERS -> MODIFIERS [83:4]
+    |   |--TYPE -> TYPE [83:4]
+    |   |   `--IDENT -> Object [83:4]
+    |   |--IDENT -> okWithPackage [83:11]
+    |   |--ASSIGN -> = [83:25]
+    |   |   `--EXPR -> EXPR [83:27]
+    |   |       `--LITERAL_NEW -> new [83:27]
+    |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [83:31]
+    |   |           |   |--GENERIC_START -> < [83:31]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [83:32]
+    |   |           |   |   `--IDENT -> String [83:32]
+    |   |           |   `--GENERIC_END -> > [83:38]
+    |   |           |--DOT -> . [83:48]
+    |   |           |   |--DOT -> . [83:43]
+    |   |           |   |   |--IDENT -> java [83:39]
+    |   |           |   |   `--IDENT -> lang [83:44]
+    |   |           |   `--IDENT -> Object [83:49]
+    |   |           |--LPAREN -> ( [83:55]
+    |   |           |--ELIST -> ELIST [83:56]
+    |   |           `--RPAREN -> ) [83:56]
+    |   `--SEMI -> ; [83:57]
+    |--VARIABLE_DEF -> VARIABLE_DEF [84:4]
+    |   |--MODIFIERS -> MODIFIERS [84:4]
+    |   |--TYPE -> TYPE [84:4]
+    |   |   `--IDENT -> Object [84:4]
+    |   |--IDENT -> ok2 [84:11]
+    |   |--ASSIGN -> = [84:15]
+    |   |   `--EXPR -> EXPR [84:17]
+    |   |       `--LITERAL_NEW -> new [84:17]
+    |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [84:21]
+    |   |           |   |--GENERIC_START -> < [84:21]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [84:22]
+    |   |           |   |   `--IDENT -> String [84:22]
+    |   |           |   `--GENERIC_END -> > [84:28]
+    |   |           |--DOT -> . [84:34]
+    |   |           |   |--IDENT -> Outer [84:29]
+    |   |           |   `--IDENT -> Inner [84:35]
+    |   |           |--LPAREN -> ( [84:40]
+    |   |           |--ELIST -> ELIST [84:41]
+    |   |           `--RPAREN -> ) [84:41]
+    |   `--SEMI -> ; [84:42]
+    |--VARIABLE_DEF -> VARIABLE_DEF [85:4]
+    |   |--MODIFIERS -> MODIFIERS [85:4]
+    |   |--TYPE -> TYPE [85:4]
+    |   |   `--IDENT -> Object [85:4]
+    |   |--IDENT -> notOkStart2 [85:11]
+    |   |--ASSIGN -> = [85:23]
+    |   |   `--EXPR -> EXPR [85:25]
+    |   |       `--LITERAL_NEW -> new [85:25]
+    |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [85:28]
+    |   |           |   |--GENERIC_START -> < [85:28]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [85:29]
+    |   |           |   |   `--IDENT -> String [85:29]
+    |   |           |   `--GENERIC_END -> > [85:35]
+    |   |           |--DOT -> . [85:41]
+    |   |           |   |--IDENT -> Outer [85:36]
+    |   |           |   `--IDENT -> Inner [85:42]
+    |   |           |--LPAREN -> ( [85:47]
+    |   |           |--ELIST -> ELIST [85:48]
+    |   |           `--RPAREN -> ) [85:48]
+    |   `--SEMI -> ; [85:49]
+    |--VARIABLE_DEF -> VARIABLE_DEF [86:4]
+    |   |--MODIFIERS -> MODIFIERS [86:4]
+    |   |--TYPE -> TYPE [86:4]
+    |   |   `--IDENT -> Object [86:4]
+    |   |--IDENT -> notOkEnd2 [86:11]
+    |   |--ASSIGN -> = [86:21]
+    |   |   `--EXPR -> EXPR [86:23]
+    |   |       `--LITERAL_NEW -> new [86:23]
+    |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [86:27]
+    |   |           |   |--GENERIC_START -> < [86:27]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [86:28]
+    |   |           |   |   `--IDENT -> String [86:28]
+    |   |           |   `--GENERIC_END -> > [86:34]
+    |   |           |--DOT -> . [86:41]
+    |   |           |   |--IDENT -> Outer [86:36]
+    |   |           |   `--IDENT -> Inner [86:42]
+    |   |           |--LPAREN -> ( [86:47]
+    |   |           |--ELIST -> ELIST [86:48]
+    |   |           `--RPAREN -> ) [86:48]
+    |   `--SEMI -> ; [86:49]
+    |--VARIABLE_DEF -> VARIABLE_DEF [87:4]
+    |   |--MODIFIERS -> MODIFIERS [87:4]
+    |   |--TYPE -> TYPE [87:4]
+    |   |   `--IDENT -> Object [87:4]
+    |   |--IDENT -> notOkStartAndEnd2 [87:11]
+    |   |--ASSIGN -> = [87:29]
+    |   |   `--EXPR -> EXPR [87:31]
+    |   |       `--LITERAL_NEW -> new [87:31]
+    |   |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [87:34]
+    |   |           |   |--GENERIC_START -> < [87:34]
+    |   |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [87:35]
+    |   |           |   |   `--IDENT -> String [87:35]
+    |   |           |   `--GENERIC_END -> > [87:41]
+    |   |           |--DOT -> . [87:48]
+    |   |           |   |--IDENT -> Outer [87:43]
+    |   |           |   `--IDENT -> Inner [87:49]
+    |   |           |--LPAREN -> ( [87:54]
+    |   |           |--ELIST -> ELIST [87:55]
+    |   |           `--RPAREN -> ) [87:55]
+    |   `--SEMI -> ; [87:56]
+    `--RCURLY -> } [88:0]
+INTERFACE_DEF -> INTERFACE_DEF [89:0]
+|--MODIFIERS -> MODIFIERS [89:0]
+|--LITERAL_INTERFACE -> interface [89:0]
+|--IDENT -> SupplierFunction [89:10]
+|--TYPE_PARAMETERS -> TYPE_PARAMETERS [89:26]
+|   |--GENERIC_START -> < [89:26]
+|   |--TYPE_PARAMETER -> TYPE_PARAMETER [89:27]
+|   |   `--IDENT -> T [89:27]
+|   `--GENERIC_END -> > [89:28]
+|--EXTENDS_CLAUSE -> extends [89:30]
+|   |--IDENT -> Map [89:38]
+|   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [89:41]
+|       |--GENERIC_START -> < [89:41]
+|       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [89:42]
+|       |   |--IDENT -> List [89:42]
+|       |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [89:46]
+|       |       |--GENERIC_START -> < [89:46]
+|       |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [89:47]
+|       |       |   `--IDENT -> T [89:47]
+|       |       `--GENERIC_END -> > [89:48]
+|       |--COMMA -> , [89:49]
+|       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [89:51]
+|       |   `--IDENT -> T [89:51]
+|       `--GENERIC_END -> > [89:52]
+`--OBJBLOCK -> OBJBLOCK [89:54]
+    |--LCURLY -> { [89:54]
+    `--RCURLY -> } [89:55]
+CLASS_DEF -> CLASS_DEF [91:0]
+|--MODIFIERS -> MODIFIERS [91:0]
+|--LITERAL_CLASS -> class [91:0]
+|--IDENT -> Outer [91:6]
+`--OBJBLOCK -> OBJBLOCK [91:12]
+    |--LCURLY -> { [91:12]
+    |--CLASS_DEF -> CLASS_DEF [92:4]
+    |   |--MODIFIERS -> MODIFIERS [92:4]
+    |   |   `--LITERAL_STATIC -> static [92:4]
+    |   |--LITERAL_CLASS -> class [92:11]
+    |   |--IDENT -> Inner [92:17]
+    |   `--OBJBLOCK -> OBJBLOCK [92:23]
+    |       |--LCURLY -> { [92:23]
+    |       `--RCURLY -> } [92:24]
+    `--RCURLY -> } [93:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputRegressionJavaAnnotation1.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputRegressionJavaAnnotation1.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputRegressionJavaAnnotation1.java
@@ -0,0 +1,16 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+@interface InputRegressionJavaAnnotation1 {
+    int f1 = 0;
+
+    String[] m1();
+    String[] m2() default {};
+
+    class SomeClass {
+        private SomeClass() {}
+    }
+}
+
+@interface ComplexAnnotation {
+    InputRegressionJavaAnnotation1[] value();
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputRegressionJavaClass1.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputRegressionJavaClass1.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputRegressionJavaClass1.java
@@ -0,0 +1,343 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class InputRegressionJavaClass1 {
+    //comments
+
+    // single line
+    /* multi on single line */
+    /* multi
+     line */
+    /** javadoc */
+    // tab ->	<-
+
+    // fields
+    // modifiers
+    public int f1;
+    private int f2;
+    protected int f3;
+    int f4;
+    static int f5;
+    final int f6;
+    volatile int f7;
+    transient int f8;
+    Object f9;
+
+    // constructors
+    static {}
+    public InputRegressionJavaClass1() {f6 = 0;}
+    public InputRegressionJavaClass1(int i) {this.f6 = i;}
+    public InputRegressionJavaClass1(float f) {this((int)f);}
+    InputRegressionJavaClass1(double a) throws Exception {f6 = 0;}
+
+    // methods
+    // modifiers
+    native void m1();
+    void m2() {}
+    synchronized void m4() {}
+    strictfp void m5() {}
+
+    // returns
+    public int[] m6() {return null;}
+    public int m7() [] {return null;}
+
+    // parameters
+    public void m10(String p1) {}
+    public void m11(final String p1) {}
+    public void m12(String[] p1) {}
+    public void m13(String[][] p1) {}
+    public void m14(String p1, String p2) {}
+    public void m15(String... p1) {}
+    public void m16(String[]... p1) {}
+    public void m17(int p1, String[]... p2) {}
+
+    // throws
+    public void m18() throws Exception {}
+    public void m19() throws IOException, Exception {}
+
+    // types
+    public <T_$> T_$ m20() {return null;}
+    public <$_T> $_T m21() {return null;}
+    public <T extends Enum<T>> void m22() {}
+    public <T> void m23() {};
+    public <T extends RuntimeException & java.io.Serializable> void m24() {}
+
+    // annotations
+    @SuppressWarnings({})
+    public void m50() {}
+    @SuppressWarnings({"1"})
+    public void m51() {}
+    @SuppressWarnings({"1","2"})
+    public void m52() {}
+    @SuppressWarnings(value={"1"})
+    public void m53() {}
+    @SuppressWarnings(value={"1",})
+    public void m54() {}
+    @SuppressWarnings(value={"1","2"})
+    public void m55() {}
+    @InputRegressionJavaAnnotation1(m1="1", m2="2")
+    public void m56() {}
+    @ComplexAnnotation({
+            @InputRegressionJavaAnnotation1(m1 = "1", m2 = ""),
+            @InputRegressionJavaAnnotation1(m1 = "1", m2 = "")
+    })
+    public void m57() {}
+    public void m58(@Deprecated String s) {}
+    public void m59(final @Deprecated List l) {}
+
+    // extra
+    {}
+    ;
+
+    // instructions
+    public void instructions() throws Exception {
+        // used to let inputs compile
+        boolean b = Math.random() > 0;
+
+        // variables and types
+        byte vbyte;
+        boolean vboolean;
+        char vchar;
+        short vshort;
+        int vint;
+        long vlong;
+        float vfloat;
+        double vdouble;
+        int[] varray;
+        int varray2[];
+        boolean test1 = true;
+
+        // types
+        String vstring;
+        List<String> vlist;
+        Map<String, String[]> vmap;
+        int[] test2 = {};
+        List<char[]> test3;
+        Class<?> test4;
+        List<? extends InputRegressionJavaClass1> test5;
+        List<? extends List<Object>> test6;
+        List<? extends List<List<Object>>> test7;
+        List<? extends int[]> test8;
+        List<? super InputRegressionJavaClass1> test9;
+
+        // literals
+        vboolean = true;
+        vboolean = false;
+        vchar = ' ';
+        vchar = '"';
+        vchar = '\0';
+        vchar = '\'';
+        vchar = '\n';
+        vchar = '\r';
+        vchar = '\t';
+        vchar = '\b';
+        vchar = '\f';
+        vchar = '\"';
+        vchar = '\'';
+        vchar = '\\';
+        vchar = '\00';
+        vchar = '\013';
+        vchar = '\4';
+        vchar = '\40';
+        vchar = '\u0000';
+        vchar = '\u1234';
+        vchar = '\u005C\u005C';
+        vchar = '\u005c\u005c';
+        vchar = '\uu005C\uuuuu005C';
+        vchar = '\u005cn';
+        vchar = '\u005cr';
+        vchar = '\u005ct';
+        vchar = '\u005cb';
+        vchar = '\u005cf';
+        vchar = '\u005c"';
+        vchar = '\u005c'';
+        vchar = '\u005c\';
+        vint = 0;
+        vint = -1;
+        vint = +1;
+        vint = 100_000;
+        vint = 0x00;
+        vint = 0x12345678;
+        vint = 0X9;
+        vint = 0x1234_5678;
+        vint = 0b101;
+        vint = 0B101;
+        vint = 0b1;
+        vint = 0b1_0;
+        vint = 012345670;
+        vint = 01234_5670;
+        vlong = 0L;
+        vlong = 1L;
+        vlong = 0b1L;
+        vlong = 1234567890l;
+        vlong = 1234567890L;
+        vlong = 0x0l;
+        vlong = 0xABCDEFl;
+        vlong = 0XABCDEFL;
+        vfloat = 0f;
+        vfloat = 0F;
+        vfloat = 1.1f;
+        vfloat = 1.10_1F;
+        vfloat = 0_1.1_1F;
+        vfloat = 1e0f;
+        vfloat = 1e0F;
+        vfloat = 1.0e0F;
+        vfloat = 0x2__3_34.4___AFP00_00f;
+        vdouble = 10.;
+        vdouble = .1;
+        vdouble = .1__1_1;
+        vdouble = 0.0;
+        vdouble = 1000.0;
+        vdouble = .1d;
+        vdouble = 1.D;
+        vdouble = 0_1.0d;
+        vdouble = 0_1.0D;
+        vdouble = 4e23;
+        vdouble = 4E23;
+        vdouble = 4E2_3;
+        vdouble = 0x0.0000000000001p-1022;
+        vdouble = 0x0.0000000000001P-1022;
+        vdouble = 0X0.0000000000001p+1022;
+        vdouble = 0X0.0000000000001P+1022;
+        vdouble = 0x.0P0;
+        vdouble = 0X0p+2;
+        vdouble = 0X0p+20F;
+        vdouble = 0X0p+2D;
+        vdouble = 0X0p+2d;
+        vdouble = 0x1.P-1;
+        vdouble = 0x.1___AFp1;
+        vstring = null;
+        vstring = "";
+        vstring = "\\";
+
+        // assignments and operators
+        vint = 1 + 1;
+        vint = 1 - 1;
+        vint = 1 * 1;
+        vint = 1 / 1;
+        vint = 1 % 1;
+        vint = 1 & 1;
+        vint = 1 | 1;
+        vint = 1 ^ 1;
+        vint = ~1;
+        vboolean = 1 != 0;
+        vboolean = 1 == 0;
+        vboolean = 1 > 0;
+        vboolean = 1 >= 0;
+        vboolean = 1 < 0;
+        vboolean = 1 <= 0;
+        vboolean = true && true;
+        vboolean = true || true;
+        vboolean = true ? true : false;
+        vboolean = !true;
+        vboolean = f9 instanceof Object;
+        vint = 1 << 1;
+        vint = 1 >> 1;
+        vint = 1 >>> 1;
+        vint += 1;
+        vint -= 1;
+        vint *= 1;
+        vint /= 1;
+        vint %= 1;
+        vint &= 1;
+        vint |= 1;
+        vint ^= 1;
+        vint <<= 1;
+        vint >>= 1;
+        vint >>>= 1;
+        vint++;
+        vint--;
+        ++vint;
+        --vint;
+        String[] arrayinit = {};
+        String[] arrayinit2 = {""};
+        String[] arrayinit3 = {"", "",};
+
+        // new
+        varray = new int[]{};
+        varray = new int[]{0};
+        varray = new int[]{0, 1};
+        varray = new int[5];
+        vlist = new ArrayList<String>();
+        vmap = new HashMap<String, String[]>();
+        Object anonymous = new InputRegressionJavaClass1() {};
+
+        // statements
+        ;
+        this.f1 = 0;
+
+        // labels
+        test_label1:
+
+        // blocks
+        {}
+        if (true) ;
+        if (true) {}
+        if (true) {} else ;
+        if (true) {} else {}
+        if (b) { for (;;) ; }
+        if (b) { for (;;) {} }
+        for (int i = 0; i < 1; i++) {}
+        for (int i = 0, j = 0; i < 1; i++, j += 2) {}
+        for (int value: new int[]{}) ;
+        for (String s : new String[]{}) ;
+        for (final String s : new String[]{}) ;
+        if (b) { while (true) ; }
+        if (b) { while (true) {} }
+        do {} while (false);
+        synchronized (f9) {}
+
+        switch (0) {
+            case 1:
+            case 0: break;
+            default: break;
+        }
+
+        try {
+            if (b) { throw new IOException(); }
+            if (b) { throw new ArrayIndexOutOfBoundsException(); }
+            throw new Exception();
+        } catch (IOException | ArrayIndexOutOfBoundsException e) {
+        } catch (Exception e) {
+        } finally {}
+        try (BufferedReader br = new BufferedReader(new InputStreamReader(null, "utf-8"))) {}
+        try (BufferedReader br1 = new BufferedReader(new InputStreamReader(null, "utf-8"));
+                BufferedReader br2 = new BufferedReader(new InputStreamReader(null, "utf-8"));) {}
+
+        // access
+        test4 = InputRegressionJavaClass1.class;
+        test4 = List[].class;
+        test4 = boolean[].class;
+        varray[0] = 0;
+        for (String[] s : new String[][]{{}}) ;
+        for (Map.Entry<String, String[]> e : vmap.entrySet()) { }
+
+        // others
+        for (;;) {break;}
+        test_label2:
+        for (;;) {break test_label2;}
+        if (b) { for (;;) {continue;} }
+        if (b) { test_label3: for (;;) {continue test_label3;} }
+        if (false) return;
+        if (false) throw new Exception();
+        assert(false);
+        assert true : "false";
+        f9 = (Object) f9;
+        f9.equals(((vstring = "")));
+        for (int i = 0; ((i) < (6+6)); i++) ;
+        if ((b & b)) {}
+
+        // ast error handling
+        vint = vboolean ? (vint = 1) : (vint = 0);
+        varray[vint] = Integer.parseInt("0");
+    }
+
+    public @interface innerAnnotation {}
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputRegressionJavaClass1Ast.txt b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputRegressionJavaClass1Ast.txt
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/InputRegressionJavaClass1Ast.txt
@@ -0,0 +1,2614 @@
+PACKAGE_DEF -> package [1:0]
+|--ANNOTATIONS -> ANNOTATIONS [1:47]
+|--DOT -> . [1:47]
+|   |--DOT -> . [1:39]
+|   |   |--DOT -> . [1:28]
+|   |   |   |--DOT -> . [1:22]
+|   |   |   |   |--DOT -> . [1:11]
+|   |   |   |   |   |--IDENT -> com [1:8]
+|   |   |   |   |   `--IDENT -> puppycrawl [1:12]
+|   |   |   |   `--IDENT -> tools [1:23]
+|   |   |   `--IDENT -> checkstyle [1:29]
+|   |   `--IDENT -> grammar [1:40]
+|   `--IDENT -> antlr4 [1:48]
+`--SEMI -> ; [1:54]
+IMPORT -> import [3:0]
+|--DOT -> . [3:14]
+|   |--DOT -> . [3:11]
+|   |   |--IDENT -> java [3:7]
+|   |   `--IDENT -> io [3:12]
+|   `--IDENT -> BufferedReader [3:15]
+`--SEMI -> ; [3:29]
+IMPORT -> import [4:0]
+|--DOT -> . [4:14]
+|   |--DOT -> . [4:11]
+|   |   |--IDENT -> java [4:7]
+|   |   `--IDENT -> io [4:12]
+|   `--IDENT -> IOException [4:15]
+`--SEMI -> ; [4:26]
+IMPORT -> import [5:0]
+|--DOT -> . [5:14]
+|   |--DOT -> . [5:11]
+|   |   |--IDENT -> java [5:7]
+|   |   `--IDENT -> io [5:12]
+|   `--IDENT -> InputStreamReader [5:15]
+`--SEMI -> ; [5:32]
+IMPORT -> import [6:0]
+|--DOT -> . [6:16]
+|   |--DOT -> . [6:11]
+|   |   |--IDENT -> java [6:7]
+|   |   `--IDENT -> util [6:12]
+|   `--IDENT -> ArrayList [6:17]
+`--SEMI -> ; [6:26]
+IMPORT -> import [7:0]
+|--DOT -> . [7:16]
+|   |--DOT -> . [7:11]
+|   |   |--IDENT -> java [7:7]
+|   |   `--IDENT -> util [7:12]
+|   `--IDENT -> HashMap [7:17]
+`--SEMI -> ; [7:24]
+IMPORT -> import [8:0]
+|--DOT -> . [8:16]
+|   |--DOT -> . [8:11]
+|   |   |--IDENT -> java [8:7]
+|   |   `--IDENT -> util [8:12]
+|   `--IDENT -> List [8:17]
+`--SEMI -> ; [8:21]
+IMPORT -> import [9:0]
+|--DOT -> . [9:16]
+|   |--DOT -> . [9:11]
+|   |   |--IDENT -> java [9:7]
+|   |   `--IDENT -> util [9:12]
+|   `--IDENT -> Map [9:17]
+`--SEMI -> ; [9:20]
+CLASS_DEF -> CLASS_DEF [11:0]
+|--MODIFIERS -> MODIFIERS [11:0]
+|   `--LITERAL_PUBLIC -> public [11:0]
+|--LITERAL_CLASS -> class [11:7]
+|--IDENT -> InputRegressionJavaClass1 [11:13]
+`--OBJBLOCK -> OBJBLOCK [11:39]
+    |--LCURLY -> { [11:39]
+    |--VARIABLE_DEF -> VARIABLE_DEF [23:4]
+    |   |--MODIFIERS -> MODIFIERS [23:4]
+    |   |   `--LITERAL_PUBLIC -> public [23:4]
+    |   |--TYPE -> TYPE [23:11]
+    |   |   `--LITERAL_INT -> int [23:11]
+    |   |--IDENT -> f1 [23:15]
+    |   `--SEMI -> ; [23:17]
+    |--VARIABLE_DEF -> VARIABLE_DEF [24:4]
+    |   |--MODIFIERS -> MODIFIERS [24:4]
+    |   |   `--LITERAL_PRIVATE -> private [24:4]
+    |   |--TYPE -> TYPE [24:12]
+    |   |   `--LITERAL_INT -> int [24:12]
+    |   |--IDENT -> f2 [24:16]
+    |   `--SEMI -> ; [24:18]
+    |--VARIABLE_DEF -> VARIABLE_DEF [25:4]
+    |   |--MODIFIERS -> MODIFIERS [25:4]
+    |   |   `--LITERAL_PROTECTED -> protected [25:4]
+    |   |--TYPE -> TYPE [25:14]
+    |   |   `--LITERAL_INT -> int [25:14]
+    |   |--IDENT -> f3 [25:18]
+    |   `--SEMI -> ; [25:20]
+    |--VARIABLE_DEF -> VARIABLE_DEF [26:4]
+    |   |--MODIFIERS -> MODIFIERS [26:4]
+    |   |--TYPE -> TYPE [26:4]
+    |   |   `--LITERAL_INT -> int [26:4]
+    |   |--IDENT -> f4 [26:8]
+    |   `--SEMI -> ; [26:10]
+    |--VARIABLE_DEF -> VARIABLE_DEF [27:4]
+    |   |--MODIFIERS -> MODIFIERS [27:4]
+    |   |   `--LITERAL_STATIC -> static [27:4]
+    |   |--TYPE -> TYPE [27:11]
+    |   |   `--LITERAL_INT -> int [27:11]
+    |   |--IDENT -> f5 [27:15]
+    |   `--SEMI -> ; [27:17]
+    |--VARIABLE_DEF -> VARIABLE_DEF [28:4]
+    |   |--MODIFIERS -> MODIFIERS [28:4]
+    |   |   `--FINAL -> final [28:4]
+    |   |--TYPE -> TYPE [28:10]
+    |   |   `--LITERAL_INT -> int [28:10]
+    |   |--IDENT -> f6 [28:14]
+    |   `--SEMI -> ; [28:16]
+    |--VARIABLE_DEF -> VARIABLE_DEF [29:4]
+    |   |--MODIFIERS -> MODIFIERS [29:4]
+    |   |   `--LITERAL_VOLATILE -> volatile [29:4]
+    |   |--TYPE -> TYPE [29:13]
+    |   |   `--LITERAL_INT -> int [29:13]
+    |   |--IDENT -> f7 [29:17]
+    |   `--SEMI -> ; [29:19]
+    |--VARIABLE_DEF -> VARIABLE_DEF [30:4]
+    |   |--MODIFIERS -> MODIFIERS [30:4]
+    |   |   `--LITERAL_TRANSIENT -> transient [30:4]
+    |   |--TYPE -> TYPE [30:14]
+    |   |   `--LITERAL_INT -> int [30:14]
+    |   |--IDENT -> f8 [30:18]
+    |   `--SEMI -> ; [30:20]
+    |--VARIABLE_DEF -> VARIABLE_DEF [31:4]
+    |   |--MODIFIERS -> MODIFIERS [31:4]
+    |   |--TYPE -> TYPE [31:4]
+    |   |   `--IDENT -> Object [31:4]
+    |   |--IDENT -> f9 [31:11]
+    |   `--SEMI -> ; [31:13]
+    |--STATIC_INIT -> STATIC_INIT [34:4]
+    |   `--SLIST -> { [34:11]
+    |       `--RCURLY -> } [34:12]
+    |--CTOR_DEF -> CTOR_DEF [35:4]
+    |   |--MODIFIERS -> MODIFIERS [35:4]
+    |   |   `--LITERAL_PUBLIC -> public [35:4]
+    |   |--IDENT -> InputRegressionJavaClass1 [35:11]
+    |   |--LPAREN -> ( [35:36]
+    |   |--PARAMETERS -> PARAMETERS [35:37]
+    |   |--RPAREN -> ) [35:37]
+    |   `--SLIST -> { [35:39]
+    |       |--EXPR -> EXPR [35:43]
+    |       |   `--ASSIGN -> = [35:43]
+    |       |       |--IDENT -> f6 [35:40]
+    |       |       `--NUM_INT -> 0 [35:45]
+    |       |--SEMI -> ; [35:46]
+    |       `--RCURLY -> } [35:47]
+    |--CTOR_DEF -> CTOR_DEF [36:4]
+    |   |--MODIFIERS -> MODIFIERS [36:4]
+    |   |   `--LITERAL_PUBLIC -> public [36:4]
+    |   |--IDENT -> InputRegressionJavaClass1 [36:11]
+    |   |--LPAREN -> ( [36:36]
+    |   |--PARAMETERS -> PARAMETERS [36:37]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [36:37]
+    |   |       |--MODIFIERS -> MODIFIERS [36:37]
+    |   |       |--TYPE -> TYPE [36:37]
+    |   |       |   `--LITERAL_INT -> int [36:37]
+    |   |       `--IDENT -> i [36:41]
+    |   |--RPAREN -> ) [36:42]
+    |   `--SLIST -> { [36:44]
+    |       |--EXPR -> EXPR [36:53]
+    |       |   `--ASSIGN -> = [36:53]
+    |       |       |--DOT -> . [36:49]
+    |       |       |   |--LITERAL_THIS -> this [36:45]
+    |       |       |   `--IDENT -> f6 [36:50]
+    |       |       `--IDENT -> i [36:55]
+    |       |--SEMI -> ; [36:56]
+    |       `--RCURLY -> } [36:57]
+    |--CTOR_DEF -> CTOR_DEF [37:4]
+    |   |--MODIFIERS -> MODIFIERS [37:4]
+    |   |   `--LITERAL_PUBLIC -> public [37:4]
+    |   |--IDENT -> InputRegressionJavaClass1 [37:11]
+    |   |--LPAREN -> ( [37:36]
+    |   |--PARAMETERS -> PARAMETERS [37:37]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [37:37]
+    |   |       |--MODIFIERS -> MODIFIERS [37:37]
+    |   |       |--TYPE -> TYPE [37:37]
+    |   |       |   `--LITERAL_FLOAT -> float [37:37]
+    |   |       `--IDENT -> f [37:43]
+    |   |--RPAREN -> ) [37:44]
+    |   `--SLIST -> { [37:46]
+    |       |--CTOR_CALL -> this [37:47]
+    |       |   |--LPAREN -> ( [37:51]
+    |       |   |--ELIST -> ELIST [37:52]
+    |       |   |   `--EXPR -> EXPR [37:52]
+    |       |   |       `--TYPECAST -> ( [37:52]
+    |       |   |           |--TYPE -> TYPE [37:53]
+    |       |   |           |   `--LITERAL_INT -> int [37:53]
+    |       |   |           |--RPAREN -> ) [37:56]
+    |       |   |           `--IDENT -> f [37:57]
+    |       |   |--RPAREN -> ) [37:58]
+    |       |   `--SEMI -> ; [37:59]
+    |       `--RCURLY -> } [37:60]
+    |--CTOR_DEF -> CTOR_DEF [38:4]
+    |   |--MODIFIERS -> MODIFIERS [38:4]
+    |   |--IDENT -> InputRegressionJavaClass1 [38:4]
+    |   |--LPAREN -> ( [38:29]
+    |   |--PARAMETERS -> PARAMETERS [38:30]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [38:30]
+    |   |       |--MODIFIERS -> MODIFIERS [38:30]
+    |   |       |--TYPE -> TYPE [38:30]
+    |   |       |   `--LITERAL_DOUBLE -> double [38:30]
+    |   |       `--IDENT -> a [38:37]
+    |   |--RPAREN -> ) [38:38]
+    |   |--LITERAL_THROWS -> throws [38:40]
+    |   |   `--IDENT -> Exception [38:47]
+    |   `--SLIST -> { [38:57]
+    |       |--EXPR -> EXPR [38:61]
+    |       |   `--ASSIGN -> = [38:61]
+    |       |       |--IDENT -> f6 [38:58]
+    |       |       `--NUM_INT -> 0 [38:63]
+    |       |--SEMI -> ; [38:64]
+    |       `--RCURLY -> } [38:65]
+    |--METHOD_DEF -> METHOD_DEF [42:4]
+    |   |--MODIFIERS -> MODIFIERS [42:4]
+    |   |   `--LITERAL_NATIVE -> native [42:4]
+    |   |--TYPE -> TYPE [42:11]
+    |   |   `--LITERAL_VOID -> void [42:11]
+    |   |--IDENT -> m1 [42:16]
+    |   |--LPAREN -> ( [42:18]
+    |   |--PARAMETERS -> PARAMETERS [42:19]
+    |   |--RPAREN -> ) [42:19]
+    |   `--SEMI -> ; [42:20]
+    |--METHOD_DEF -> METHOD_DEF [43:4]
+    |   |--MODIFIERS -> MODIFIERS [43:4]
+    |   |--TYPE -> TYPE [43:4]
+    |   |   `--LITERAL_VOID -> void [43:4]
+    |   |--IDENT -> m2 [43:9]
+    |   |--LPAREN -> ( [43:11]
+    |   |--PARAMETERS -> PARAMETERS [43:12]
+    |   |--RPAREN -> ) [43:12]
+    |   `--SLIST -> { [43:14]
+    |       `--RCURLY -> } [43:15]
+    |--METHOD_DEF -> METHOD_DEF [44:4]
+    |   |--MODIFIERS -> MODIFIERS [44:4]
+    |   |   `--LITERAL_SYNCHRONIZED -> synchronized [44:4]
+    |   |--TYPE -> TYPE [44:17]
+    |   |   `--LITERAL_VOID -> void [44:17]
+    |   |--IDENT -> m4 [44:22]
+    |   |--LPAREN -> ( [44:24]
+    |   |--PARAMETERS -> PARAMETERS [44:25]
+    |   |--RPAREN -> ) [44:25]
+    |   `--SLIST -> { [44:27]
+    |       `--RCURLY -> } [44:28]
+    |--METHOD_DEF -> METHOD_DEF [45:4]
+    |   |--MODIFIERS -> MODIFIERS [45:4]
+    |   |   `--STRICTFP -> strictfp [45:4]
+    |   |--TYPE -> TYPE [45:13]
+    |   |   `--LITERAL_VOID -> void [45:13]
+    |   |--IDENT -> m5 [45:18]
+    |   |--LPAREN -> ( [45:20]
+    |   |--PARAMETERS -> PARAMETERS [45:21]
+    |   |--RPAREN -> ) [45:21]
+    |   `--SLIST -> { [45:23]
+    |       `--RCURLY -> } [45:24]
+    |--METHOD_DEF -> METHOD_DEF [48:4]
+    |   |--MODIFIERS -> MODIFIERS [48:4]
+    |   |   `--LITERAL_PUBLIC -> public [48:4]
+    |   |--TYPE -> TYPE [48:11]
+    |   |   |--LITERAL_INT -> int [48:11]
+    |   |   `--ARRAY_DECLARATOR -> [ [48:14]
+    |   |       `--RBRACK -> ] [48:15]
+    |   |--IDENT -> m6 [48:17]
+    |   |--LPAREN -> ( [48:19]
+    |   |--PARAMETERS -> PARAMETERS [48:20]
+    |   |--RPAREN -> ) [48:20]
+    |   `--SLIST -> { [48:22]
+    |       |--LITERAL_RETURN -> return [48:23]
+    |       |   |--EXPR -> EXPR [48:30]
+    |       |   |   `--LITERAL_NULL -> null [48:30]
+    |       |   `--SEMI -> ; [48:34]
+    |       `--RCURLY -> } [48:35]
+    |--METHOD_DEF -> METHOD_DEF [49:4]
+    |   |--MODIFIERS -> MODIFIERS [49:4]
+    |   |   `--LITERAL_PUBLIC -> public [49:4]
+    |   |--TYPE -> TYPE [49:11]
+    |   |   |--LITERAL_INT -> int [49:11]
+    |   |   `--ARRAY_DECLARATOR -> [ [49:20]
+    |   |       `--RBRACK -> ] [49:21]
+    |   |--IDENT -> m7 [49:15]
+    |   |--LPAREN -> ( [49:17]
+    |   |--PARAMETERS -> PARAMETERS [49:18]
+    |   |--RPAREN -> ) [49:18]
+    |   `--SLIST -> { [49:23]
+    |       |--LITERAL_RETURN -> return [49:24]
+    |       |   |--EXPR -> EXPR [49:31]
+    |       |   |   `--LITERAL_NULL -> null [49:31]
+    |       |   `--SEMI -> ; [49:35]
+    |       `--RCURLY -> } [49:36]
+    |--METHOD_DEF -> METHOD_DEF [52:4]
+    |   |--MODIFIERS -> MODIFIERS [52:4]
+    |   |   `--LITERAL_PUBLIC -> public [52:4]
+    |   |--TYPE -> TYPE [52:11]
+    |   |   `--LITERAL_VOID -> void [52:11]
+    |   |--IDENT -> m10 [52:16]
+    |   |--LPAREN -> ( [52:19]
+    |   |--PARAMETERS -> PARAMETERS [52:20]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [52:20]
+    |   |       |--MODIFIERS -> MODIFIERS [52:20]
+    |   |       |--TYPE -> TYPE [52:20]
+    |   |       |   `--IDENT -> String [52:20]
+    |   |       `--IDENT -> p1 [52:27]
+    |   |--RPAREN -> ) [52:29]
+    |   `--SLIST -> { [52:31]
+    |       `--RCURLY -> } [52:32]
+    |--METHOD_DEF -> METHOD_DEF [53:4]
+    |   |--MODIFIERS -> MODIFIERS [53:4]
+    |   |   `--LITERAL_PUBLIC -> public [53:4]
+    |   |--TYPE -> TYPE [53:11]
+    |   |   `--LITERAL_VOID -> void [53:11]
+    |   |--IDENT -> m11 [53:16]
+    |   |--LPAREN -> ( [53:19]
+    |   |--PARAMETERS -> PARAMETERS [53:20]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [53:20]
+    |   |       |--MODIFIERS -> MODIFIERS [53:20]
+    |   |       |   `--FINAL -> final [53:20]
+    |   |       |--TYPE -> TYPE [53:26]
+    |   |       |   `--IDENT -> String [53:26]
+    |   |       `--IDENT -> p1 [53:33]
+    |   |--RPAREN -> ) [53:35]
+    |   `--SLIST -> { [53:37]
+    |       `--RCURLY -> } [53:38]
+    |--METHOD_DEF -> METHOD_DEF [54:4]
+    |   |--MODIFIERS -> MODIFIERS [54:4]
+    |   |   `--LITERAL_PUBLIC -> public [54:4]
+    |   |--TYPE -> TYPE [54:11]
+    |   |   `--LITERAL_VOID -> void [54:11]
+    |   |--IDENT -> m12 [54:16]
+    |   |--LPAREN -> ( [54:19]
+    |   |--PARAMETERS -> PARAMETERS [54:20]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [54:20]
+    |   |       |--MODIFIERS -> MODIFIERS [54:20]
+    |   |       |--TYPE -> TYPE [54:20]
+    |   |       |   |--IDENT -> String [54:20]
+    |   |       |   `--ARRAY_DECLARATOR -> [ [54:26]
+    |   |       |       `--RBRACK -> ] [54:27]
+    |   |       `--IDENT -> p1 [54:29]
+    |   |--RPAREN -> ) [54:31]
+    |   `--SLIST -> { [54:33]
+    |       `--RCURLY -> } [54:34]
+    |--METHOD_DEF -> METHOD_DEF [55:4]
+    |   |--MODIFIERS -> MODIFIERS [55:4]
+    |   |   `--LITERAL_PUBLIC -> public [55:4]
+    |   |--TYPE -> TYPE [55:11]
+    |   |   `--LITERAL_VOID -> void [55:11]
+    |   |--IDENT -> m13 [55:16]
+    |   |--LPAREN -> ( [55:19]
+    |   |--PARAMETERS -> PARAMETERS [55:20]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [55:20]
+    |   |       |--MODIFIERS -> MODIFIERS [55:20]
+    |   |       |--TYPE -> TYPE [55:20]
+    |   |       |   |--IDENT -> String [55:20]
+    |   |       |   |--ARRAY_DECLARATOR -> [ [55:26]
+    |   |       |   |   `--RBRACK -> ] [55:27]
+    |   |       |   `--ARRAY_DECLARATOR -> [ [55:28]
+    |   |       |       `--RBRACK -> ] [55:29]
+    |   |       `--IDENT -> p1 [55:31]
+    |   |--RPAREN -> ) [55:33]
+    |   `--SLIST -> { [55:35]
+    |       `--RCURLY -> } [55:36]
+    |--METHOD_DEF -> METHOD_DEF [56:4]
+    |   |--MODIFIERS -> MODIFIERS [56:4]
+    |   |   `--LITERAL_PUBLIC -> public [56:4]
+    |   |--TYPE -> TYPE [56:11]
+    |   |   `--LITERAL_VOID -> void [56:11]
+    |   |--IDENT -> m14 [56:16]
+    |   |--LPAREN -> ( [56:19]
+    |   |--PARAMETERS -> PARAMETERS [56:20]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [56:20]
+    |   |   |   |--MODIFIERS -> MODIFIERS [56:20]
+    |   |   |   |--TYPE -> TYPE [56:20]
+    |   |   |   |   `--IDENT -> String [56:20]
+    |   |   |   `--IDENT -> p1 [56:27]
+    |   |   |--COMMA -> , [56:29]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [56:31]
+    |   |       |--MODIFIERS -> MODIFIERS [56:31]
+    |   |       |--TYPE -> TYPE [56:31]
+    |   |       |   `--IDENT -> String [56:31]
+    |   |       `--IDENT -> p2 [56:38]
+    |   |--RPAREN -> ) [56:40]
+    |   `--SLIST -> { [56:42]
+    |       `--RCURLY -> } [56:43]
+    |--METHOD_DEF -> METHOD_DEF [57:4]
+    |   |--MODIFIERS -> MODIFIERS [57:4]
+    |   |   `--LITERAL_PUBLIC -> public [57:4]
+    |   |--TYPE -> TYPE [57:11]
+    |   |   `--LITERAL_VOID -> void [57:11]
+    |   |--IDENT -> m15 [57:16]
+    |   |--LPAREN -> ( [57:19]
+    |   |--PARAMETERS -> PARAMETERS [57:20]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [57:20]
+    |   |       |--MODIFIERS -> MODIFIERS [57:20]
+    |   |       |--TYPE -> TYPE [57:20]
+    |   |       |   `--IDENT -> String [57:20]
+    |   |       |--ELLIPSIS -> ... [57:26]
+    |   |       `--IDENT -> p1 [57:30]
+    |   |--RPAREN -> ) [57:32]
+    |   `--SLIST -> { [57:34]
+    |       `--RCURLY -> } [57:35]
+    |--METHOD_DEF -> METHOD_DEF [58:4]
+    |   |--MODIFIERS -> MODIFIERS [58:4]
+    |   |   `--LITERAL_PUBLIC -> public [58:4]
+    |   |--TYPE -> TYPE [58:11]
+    |   |   `--LITERAL_VOID -> void [58:11]
+    |   |--IDENT -> m16 [58:16]
+    |   |--LPAREN -> ( [58:19]
+    |   |--PARAMETERS -> PARAMETERS [58:20]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [58:20]
+    |   |       |--MODIFIERS -> MODIFIERS [58:20]
+    |   |       |--TYPE -> TYPE [58:20]
+    |   |       |   |--IDENT -> String [58:20]
+    |   |       |   `--ARRAY_DECLARATOR -> [ [58:26]
+    |   |       |       `--RBRACK -> ] [58:27]
+    |   |       |--ELLIPSIS -> ... [58:28]
+    |   |       `--IDENT -> p1 [58:32]
+    |   |--RPAREN -> ) [58:34]
+    |   `--SLIST -> { [58:36]
+    |       `--RCURLY -> } [58:37]
+    |--METHOD_DEF -> METHOD_DEF [59:4]
+    |   |--MODIFIERS -> MODIFIERS [59:4]
+    |   |   `--LITERAL_PUBLIC -> public [59:4]
+    |   |--TYPE -> TYPE [59:11]
+    |   |   `--LITERAL_VOID -> void [59:11]
+    |   |--IDENT -> m17 [59:16]
+    |   |--LPAREN -> ( [59:19]
+    |   |--PARAMETERS -> PARAMETERS [59:20]
+    |   |   |--PARAMETER_DEF -> PARAMETER_DEF [59:20]
+    |   |   |   |--MODIFIERS -> MODIFIERS [59:20]
+    |   |   |   |--TYPE -> TYPE [59:20]
+    |   |   |   |   `--LITERAL_INT -> int [59:20]
+    |   |   |   `--IDENT -> p1 [59:24]
+    |   |   |--COMMA -> , [59:26]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [59:28]
+    |   |       |--MODIFIERS -> MODIFIERS [59:28]
+    |   |       |--TYPE -> TYPE [59:28]
+    |   |       |   |--IDENT -> String [59:28]
+    |   |       |   `--ARRAY_DECLARATOR -> [ [59:34]
+    |   |       |       `--RBRACK -> ] [59:35]
+    |   |       |--ELLIPSIS -> ... [59:36]
+    |   |       `--IDENT -> p2 [59:40]
+    |   |--RPAREN -> ) [59:42]
+    |   `--SLIST -> { [59:44]
+    |       `--RCURLY -> } [59:45]
+    |--METHOD_DEF -> METHOD_DEF [62:4]
+    |   |--MODIFIERS -> MODIFIERS [62:4]
+    |   |   `--LITERAL_PUBLIC -> public [62:4]
+    |   |--TYPE -> TYPE [62:11]
+    |   |   `--LITERAL_VOID -> void [62:11]
+    |   |--IDENT -> m18 [62:16]
+    |   |--LPAREN -> ( [62:19]
+    |   |--PARAMETERS -> PARAMETERS [62:20]
+    |   |--RPAREN -> ) [62:20]
+    |   |--LITERAL_THROWS -> throws [62:22]
+    |   |   `--IDENT -> Exception [62:29]
+    |   `--SLIST -> { [62:39]
+    |       `--RCURLY -> } [62:40]
+    |--METHOD_DEF -> METHOD_DEF [63:4]
+    |   |--MODIFIERS -> MODIFIERS [63:4]
+    |   |   `--LITERAL_PUBLIC -> public [63:4]
+    |   |--TYPE -> TYPE [63:11]
+    |   |   `--LITERAL_VOID -> void [63:11]
+    |   |--IDENT -> m19 [63:16]
+    |   |--LPAREN -> ( [63:19]
+    |   |--PARAMETERS -> PARAMETERS [63:20]
+    |   |--RPAREN -> ) [63:20]
+    |   |--LITERAL_THROWS -> throws [63:22]
+    |   |   |--IDENT -> IOException [63:29]
+    |   |   |--COMMA -> , [63:40]
+    |   |   `--IDENT -> Exception [63:42]
+    |   `--SLIST -> { [63:52]
+    |       `--RCURLY -> } [63:53]
+    |--METHOD_DEF -> METHOD_DEF [66:4]
+    |   |--MODIFIERS -> MODIFIERS [66:4]
+    |   |   `--LITERAL_PUBLIC -> public [66:4]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [66:11]
+    |   |   |--GENERIC_START -> < [66:11]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [66:12]
+    |   |   |   `--IDENT -> T_$ [66:12]
+    |   |   `--GENERIC_END -> > [66:15]
+    |   |--TYPE -> TYPE [66:17]
+    |   |   `--IDENT -> T_$ [66:17]
+    |   |--IDENT -> m20 [66:21]
+    |   |--LPAREN -> ( [66:24]
+    |   |--PARAMETERS -> PARAMETERS [66:25]
+    |   |--RPAREN -> ) [66:25]
+    |   `--SLIST -> { [66:27]
+    |       |--LITERAL_RETURN -> return [66:28]
+    |       |   |--EXPR -> EXPR [66:35]
+    |       |   |   `--LITERAL_NULL -> null [66:35]
+    |       |   `--SEMI -> ; [66:39]
+    |       `--RCURLY -> } [66:40]
+    |--METHOD_DEF -> METHOD_DEF [67:4]
+    |   |--MODIFIERS -> MODIFIERS [67:4]
+    |   |   `--LITERAL_PUBLIC -> public [67:4]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [67:11]
+    |   |   |--GENERIC_START -> < [67:11]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [67:12]
+    |   |   |   `--IDENT -> $_T [67:12]
+    |   |   `--GENERIC_END -> > [67:15]
+    |   |--TYPE -> TYPE [67:17]
+    |   |   `--IDENT -> $_T [67:17]
+    |   |--IDENT -> m21 [67:21]
+    |   |--LPAREN -> ( [67:24]
+    |   |--PARAMETERS -> PARAMETERS [67:25]
+    |   |--RPAREN -> ) [67:25]
+    |   `--SLIST -> { [67:27]
+    |       |--LITERAL_RETURN -> return [67:28]
+    |       |   |--EXPR -> EXPR [67:35]
+    |       |   |   `--LITERAL_NULL -> null [67:35]
+    |       |   `--SEMI -> ; [67:39]
+    |       `--RCURLY -> } [67:40]
+    |--METHOD_DEF -> METHOD_DEF [68:4]
+    |   |--MODIFIERS -> MODIFIERS [68:4]
+    |   |   `--LITERAL_PUBLIC -> public [68:4]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [68:11]
+    |   |   |--GENERIC_START -> < [68:11]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [68:12]
+    |   |   |   |--IDENT -> T [68:12]
+    |   |   |   `--TYPE_UPPER_BOUNDS -> extends [68:14]
+    |   |   |       |--IDENT -> Enum [68:22]
+    |   |   |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [68:26]
+    |   |   |           |--GENERIC_START -> < [68:26]
+    |   |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [68:27]
+    |   |   |           |   `--IDENT -> T [68:27]
+    |   |   |           `--GENERIC_END -> > [68:28]
+    |   |   `--GENERIC_END -> > [68:29]
+    |   |--TYPE -> TYPE [68:31]
+    |   |   `--LITERAL_VOID -> void [68:31]
+    |   |--IDENT -> m22 [68:36]
+    |   |--LPAREN -> ( [68:39]
+    |   |--PARAMETERS -> PARAMETERS [68:40]
+    |   |--RPAREN -> ) [68:40]
+    |   `--SLIST -> { [68:42]
+    |       `--RCURLY -> } [68:43]
+    |--METHOD_DEF -> METHOD_DEF [69:4]
+    |   |--MODIFIERS -> MODIFIERS [69:4]
+    |   |   `--LITERAL_PUBLIC -> public [69:4]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [69:11]
+    |   |   |--GENERIC_START -> < [69:11]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [69:12]
+    |   |   |   `--IDENT -> T [69:12]
+    |   |   `--GENERIC_END -> > [69:13]
+    |   |--TYPE -> TYPE [69:15]
+    |   |   `--LITERAL_VOID -> void [69:15]
+    |   |--IDENT -> m23 [69:20]
+    |   |--LPAREN -> ( [69:23]
+    |   |--PARAMETERS -> PARAMETERS [69:24]
+    |   |--RPAREN -> ) [69:24]
+    |   `--SLIST -> { [69:26]
+    |       `--RCURLY -> } [69:27]
+    |--SEMI -> ; [69:28]
+    |--METHOD_DEF -> METHOD_DEF [70:4]
+    |   |--MODIFIERS -> MODIFIERS [70:4]
+    |   |   `--LITERAL_PUBLIC -> public [70:4]
+    |   |--TYPE_PARAMETERS -> TYPE_PARAMETERS [70:11]
+    |   |   |--GENERIC_START -> < [70:11]
+    |   |   |--TYPE_PARAMETER -> TYPE_PARAMETER [70:12]
+    |   |   |   |--IDENT -> T [70:12]
+    |   |   |   `--TYPE_UPPER_BOUNDS -> extends [70:14]
+    |   |   |       |--IDENT -> RuntimeException [70:22]
+    |   |   |       |--TYPE_EXTENSION_AND -> & [70:39]
+    |   |   |       `--DOT -> . [70:48]
+    |   |   |           |--DOT -> . [70:45]
+    |   |   |           |   |--IDENT -> java [70:41]
+    |   |   |           |   `--IDENT -> io [70:46]
+    |   |   |           `--IDENT -> Serializable [70:49]
+    |   |   `--GENERIC_END -> > [70:61]
+    |   |--TYPE -> TYPE [70:63]
+    |   |   `--LITERAL_VOID -> void [70:63]
+    |   |--IDENT -> m24 [70:68]
+    |   |--LPAREN -> ( [70:71]
+    |   |--PARAMETERS -> PARAMETERS [70:72]
+    |   |--RPAREN -> ) [70:72]
+    |   `--SLIST -> { [70:74]
+    |       `--RCURLY -> } [70:75]
+    |--METHOD_DEF -> METHOD_DEF [73:4]
+    |   |--MODIFIERS -> MODIFIERS [73:4]
+    |   |   |--ANNOTATION -> ANNOTATION [73:4]
+    |   |   |   |--AT -> @ [73:4]
+    |   |   |   |--IDENT -> SuppressWarnings [73:5]
+    |   |   |   |--LPAREN -> ( [73:21]
+    |   |   |   |--ANNOTATION_ARRAY_INIT -> { [73:22]
+    |   |   |   |   `--RCURLY -> } [73:23]
+    |   |   |   `--RPAREN -> ) [73:24]
+    |   |   `--LITERAL_PUBLIC -> public [74:4]
+    |   |--TYPE -> TYPE [74:11]
+    |   |   `--LITERAL_VOID -> void [74:11]
+    |   |--IDENT -> m50 [74:16]
+    |   |--LPAREN -> ( [74:19]
+    |   |--PARAMETERS -> PARAMETERS [74:20]
+    |   |--RPAREN -> ) [74:20]
+    |   `--SLIST -> { [74:22]
+    |       `--RCURLY -> } [74:23]
+    |--METHOD_DEF -> METHOD_DEF [75:4]
+    |   |--MODIFIERS -> MODIFIERS [75:4]
+    |   |   |--ANNOTATION -> ANNOTATION [75:4]
+    |   |   |   |--AT -> @ [75:4]
+    |   |   |   |--IDENT -> SuppressWarnings [75:5]
+    |   |   |   |--LPAREN -> ( [75:21]
+    |   |   |   |--ANNOTATION_ARRAY_INIT -> { [75:22]
+    |   |   |   |   |--EXPR -> EXPR [75:23]
+    |   |   |   |   |   `--STRING_LITERAL -> "1" [75:23]
+    |   |   |   |   `--RCURLY -> } [75:26]
+    |   |   |   `--RPAREN -> ) [75:27]
+    |   |   `--LITERAL_PUBLIC -> public [76:4]
+    |   |--TYPE -> TYPE [76:11]
+    |   |   `--LITERAL_VOID -> void [76:11]
+    |   |--IDENT -> m51 [76:16]
+    |   |--LPAREN -> ( [76:19]
+    |   |--PARAMETERS -> PARAMETERS [76:20]
+    |   |--RPAREN -> ) [76:20]
+    |   `--SLIST -> { [76:22]
+    |       `--RCURLY -> } [76:23]
+    |--METHOD_DEF -> METHOD_DEF [77:4]
+    |   |--MODIFIERS -> MODIFIERS [77:4]
+    |   |   |--ANNOTATION -> ANNOTATION [77:4]
+    |   |   |   |--AT -> @ [77:4]
+    |   |   |   |--IDENT -> SuppressWarnings [77:5]
+    |   |   |   |--LPAREN -> ( [77:21]
+    |   |   |   |--ANNOTATION_ARRAY_INIT -> { [77:22]
+    |   |   |   |   |--EXPR -> EXPR [77:23]
+    |   |   |   |   |   `--STRING_LITERAL -> "1" [77:23]
+    |   |   |   |   |--COMMA -> , [77:26]
+    |   |   |   |   |--EXPR -> EXPR [77:27]
+    |   |   |   |   |   `--STRING_LITERAL -> "2" [77:27]
+    |   |   |   |   `--RCURLY -> } [77:30]
+    |   |   |   `--RPAREN -> ) [77:31]
+    |   |   `--LITERAL_PUBLIC -> public [78:4]
+    |   |--TYPE -> TYPE [78:11]
+    |   |   `--LITERAL_VOID -> void [78:11]
+    |   |--IDENT -> m52 [78:16]
+    |   |--LPAREN -> ( [78:19]
+    |   |--PARAMETERS -> PARAMETERS [78:20]
+    |   |--RPAREN -> ) [78:20]
+    |   `--SLIST -> { [78:22]
+    |       `--RCURLY -> } [78:23]
+    |--METHOD_DEF -> METHOD_DEF [79:4]
+    |   |--MODIFIERS -> MODIFIERS [79:4]
+    |   |   |--ANNOTATION -> ANNOTATION [79:4]
+    |   |   |   |--AT -> @ [79:4]
+    |   |   |   |--IDENT -> SuppressWarnings [79:5]
+    |   |   |   |--LPAREN -> ( [79:21]
+    |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [79:22]
+    |   |   |   |   |--IDENT -> value [79:22]
+    |   |   |   |   |--ASSIGN -> = [79:27]
+    |   |   |   |   `--ANNOTATION_ARRAY_INIT -> { [79:28]
+    |   |   |   |       |--EXPR -> EXPR [79:29]
+    |   |   |   |       |   `--STRING_LITERAL -> "1" [79:29]
+    |   |   |   |       `--RCURLY -> } [79:32]
+    |   |   |   `--RPAREN -> ) [79:33]
+    |   |   `--LITERAL_PUBLIC -> public [80:4]
+    |   |--TYPE -> TYPE [80:11]
+    |   |   `--LITERAL_VOID -> void [80:11]
+    |   |--IDENT -> m53 [80:16]
+    |   |--LPAREN -> ( [80:19]
+    |   |--PARAMETERS -> PARAMETERS [80:20]
+    |   |--RPAREN -> ) [80:20]
+    |   `--SLIST -> { [80:22]
+    |       `--RCURLY -> } [80:23]
+    |--METHOD_DEF -> METHOD_DEF [81:4]
+    |   |--MODIFIERS -> MODIFIERS [81:4]
+    |   |   |--ANNOTATION -> ANNOTATION [81:4]
+    |   |   |   |--AT -> @ [81:4]
+    |   |   |   |--IDENT -> SuppressWarnings [81:5]
+    |   |   |   |--LPAREN -> ( [81:21]
+    |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [81:22]
+    |   |   |   |   |--IDENT -> value [81:22]
+    |   |   |   |   |--ASSIGN -> = [81:27]
+    |   |   |   |   `--ANNOTATION_ARRAY_INIT -> { [81:28]
+    |   |   |   |       |--EXPR -> EXPR [81:29]
+    |   |   |   |       |   `--STRING_LITERAL -> "1" [81:29]
+    |   |   |   |       |--COMMA -> , [81:32]
+    |   |   |   |       `--RCURLY -> } [81:33]
+    |   |   |   `--RPAREN -> ) [81:34]
+    |   |   `--LITERAL_PUBLIC -> public [82:4]
+    |   |--TYPE -> TYPE [82:11]
+    |   |   `--LITERAL_VOID -> void [82:11]
+    |   |--IDENT -> m54 [82:16]
+    |   |--LPAREN -> ( [82:19]
+    |   |--PARAMETERS -> PARAMETERS [82:20]
+    |   |--RPAREN -> ) [82:20]
+    |   `--SLIST -> { [82:22]
+    |       `--RCURLY -> } [82:23]
+    |--METHOD_DEF -> METHOD_DEF [83:4]
+    |   |--MODIFIERS -> MODIFIERS [83:4]
+    |   |   |--ANNOTATION -> ANNOTATION [83:4]
+    |   |   |   |--AT -> @ [83:4]
+    |   |   |   |--IDENT -> SuppressWarnings [83:5]
+    |   |   |   |--LPAREN -> ( [83:21]
+    |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [83:22]
+    |   |   |   |   |--IDENT -> value [83:22]
+    |   |   |   |   |--ASSIGN -> = [83:27]
+    |   |   |   |   `--ANNOTATION_ARRAY_INIT -> { [83:28]
+    |   |   |   |       |--EXPR -> EXPR [83:29]
+    |   |   |   |       |   `--STRING_LITERAL -> "1" [83:29]
+    |   |   |   |       |--COMMA -> , [83:32]
+    |   |   |   |       |--EXPR -> EXPR [83:33]
+    |   |   |   |       |   `--STRING_LITERAL -> "2" [83:33]
+    |   |   |   |       `--RCURLY -> } [83:36]
+    |   |   |   `--RPAREN -> ) [83:37]
+    |   |   `--LITERAL_PUBLIC -> public [84:4]
+    |   |--TYPE -> TYPE [84:11]
+    |   |   `--LITERAL_VOID -> void [84:11]
+    |   |--IDENT -> m55 [84:16]
+    |   |--LPAREN -> ( [84:19]
+    |   |--PARAMETERS -> PARAMETERS [84:20]
+    |   |--RPAREN -> ) [84:20]
+    |   `--SLIST -> { [84:22]
+    |       `--RCURLY -> } [84:23]
+    |--METHOD_DEF -> METHOD_DEF [85:4]
+    |   |--MODIFIERS -> MODIFIERS [85:4]
+    |   |   |--ANNOTATION -> ANNOTATION [85:4]
+    |   |   |   |--AT -> @ [85:4]
+    |   |   |   |--IDENT -> InputRegressionJavaAnnotation1 [85:5]
+    |   |   |   |--LPAREN -> ( [85:35]
+    |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [85:36]
+    |   |   |   |   |--IDENT -> m1 [85:36]
+    |   |   |   |   |--ASSIGN -> = [85:38]
+    |   |   |   |   `--EXPR -> EXPR [85:39]
+    |   |   |   |       `--STRING_LITERAL -> "1" [85:39]
+    |   |   |   |--COMMA -> , [85:42]
+    |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [85:44]
+    |   |   |   |   |--IDENT -> m2 [85:44]
+    |   |   |   |   |--ASSIGN -> = [85:46]
+    |   |   |   |   `--EXPR -> EXPR [85:47]
+    |   |   |   |       `--STRING_LITERAL -> "2" [85:47]
+    |   |   |   `--RPAREN -> ) [85:50]
+    |   |   `--LITERAL_PUBLIC -> public [86:4]
+    |   |--TYPE -> TYPE [86:11]
+    |   |   `--LITERAL_VOID -> void [86:11]
+    |   |--IDENT -> m56 [86:16]
+    |   |--LPAREN -> ( [86:19]
+    |   |--PARAMETERS -> PARAMETERS [86:20]
+    |   |--RPAREN -> ) [86:20]
+    |   `--SLIST -> { [86:22]
+    |       `--RCURLY -> } [86:23]
+    |--METHOD_DEF -> METHOD_DEF [87:4]
+    |   |--MODIFIERS -> MODIFIERS [87:4]
+    |   |   |--ANNOTATION -> ANNOTATION [87:4]
+    |   |   |   |--AT -> @ [87:4]
+    |   |   |   |--IDENT -> ComplexAnnotation [87:5]
+    |   |   |   |--LPAREN -> ( [87:22]
+    |   |   |   |--ANNOTATION_ARRAY_INIT -> { [87:23]
+    |   |   |   |   |--ANNOTATION -> ANNOTATION [88:12]
+    |   |   |   |   |   |--AT -> @ [88:12]
+    |   |   |   |   |   |--IDENT -> InputRegressionJavaAnnotation1 [88:13]
+    |   |   |   |   |   |--LPAREN -> ( [88:43]
+    |   |   |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [88:44]
+    |   |   |   |   |   |   |--IDENT -> m1 [88:44]
+    |   |   |   |   |   |   |--ASSIGN -> = [88:47]
+    |   |   |   |   |   |   `--EXPR -> EXPR [88:49]
+    |   |   |   |   |   |       `--STRING_LITERAL -> "1" [88:49]
+    |   |   |   |   |   |--COMMA -> , [88:52]
+    |   |   |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [88:54]
+    |   |   |   |   |   |   |--IDENT -> m2 [88:54]
+    |   |   |   |   |   |   |--ASSIGN -> = [88:57]
+    |   |   |   |   |   |   `--EXPR -> EXPR [88:59]
+    |   |   |   |   |   |       `--STRING_LITERAL -> "" [88:59]
+    |   |   |   |   |   `--RPAREN -> ) [88:61]
+    |   |   |   |   |--COMMA -> , [88:62]
+    |   |   |   |   |--ANNOTATION -> ANNOTATION [89:12]
+    |   |   |   |   |   |--AT -> @ [89:12]
+    |   |   |   |   |   |--IDENT -> InputRegressionJavaAnnotation1 [89:13]
+    |   |   |   |   |   |--LPAREN -> ( [89:43]
+    |   |   |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [89:44]
+    |   |   |   |   |   |   |--IDENT -> m1 [89:44]
+    |   |   |   |   |   |   |--ASSIGN -> = [89:47]
+    |   |   |   |   |   |   `--EXPR -> EXPR [89:49]
+    |   |   |   |   |   |       `--STRING_LITERAL -> "1" [89:49]
+    |   |   |   |   |   |--COMMA -> , [89:52]
+    |   |   |   |   |   |--ANNOTATION_MEMBER_VALUE_PAIR -> ANNOTATION_MEMBER_VALUE_PAIR [89:54]
+    |   |   |   |   |   |   |--IDENT -> m2 [89:54]
+    |   |   |   |   |   |   |--ASSIGN -> = [89:57]
+    |   |   |   |   |   |   `--EXPR -> EXPR [89:59]
+    |   |   |   |   |   |       `--STRING_LITERAL -> "" [89:59]
+    |   |   |   |   |   `--RPAREN -> ) [89:61]
+    |   |   |   |   `--RCURLY -> } [90:4]
+    |   |   |   `--RPAREN -> ) [90:5]
+    |   |   `--LITERAL_PUBLIC -> public [91:4]
+    |   |--TYPE -> TYPE [91:11]
+    |   |   `--LITERAL_VOID -> void [91:11]
+    |   |--IDENT -> m57 [91:16]
+    |   |--LPAREN -> ( [91:19]
+    |   |--PARAMETERS -> PARAMETERS [91:20]
+    |   |--RPAREN -> ) [91:20]
+    |   `--SLIST -> { [91:22]
+    |       `--RCURLY -> } [91:23]
+    |--METHOD_DEF -> METHOD_DEF [92:4]
+    |   |--MODIFIERS -> MODIFIERS [92:4]
+    |   |   `--LITERAL_PUBLIC -> public [92:4]
+    |   |--TYPE -> TYPE [92:11]
+    |   |   `--LITERAL_VOID -> void [92:11]
+    |   |--IDENT -> m58 [92:16]
+    |   |--LPAREN -> ( [92:19]
+    |   |--PARAMETERS -> PARAMETERS [92:20]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [92:20]
+    |   |       |--MODIFIERS -> MODIFIERS [92:20]
+    |   |       |   `--ANNOTATION -> ANNOTATION [92:20]
+    |   |       |       |--AT -> @ [92:20]
+    |   |       |       `--IDENT -> Deprecated [92:21]
+    |   |       |--TYPE -> TYPE [92:32]
+    |   |       |   `--IDENT -> String [92:32]
+    |   |       `--IDENT -> s [92:39]
+    |   |--RPAREN -> ) [92:40]
+    |   `--SLIST -> { [92:42]
+    |       `--RCURLY -> } [92:43]
+    |--METHOD_DEF -> METHOD_DEF [93:4]
+    |   |--MODIFIERS -> MODIFIERS [93:4]
+    |   |   `--LITERAL_PUBLIC -> public [93:4]
+    |   |--TYPE -> TYPE [93:11]
+    |   |   `--LITERAL_VOID -> void [93:11]
+    |   |--IDENT -> m59 [93:16]
+    |   |--LPAREN -> ( [93:19]
+    |   |--PARAMETERS -> PARAMETERS [93:20]
+    |   |   `--PARAMETER_DEF -> PARAMETER_DEF [93:20]
+    |   |       |--MODIFIERS -> MODIFIERS [93:20]
+    |   |       |   |--FINAL -> final [93:20]
+    |   |       |   `--ANNOTATION -> ANNOTATION [93:26]
+    |   |       |       |--AT -> @ [93:26]
+    |   |       |       `--IDENT -> Deprecated [93:27]
+    |   |       |--TYPE -> TYPE [93:38]
+    |   |       |   `--IDENT -> List [93:38]
+    |   |       `--IDENT -> l [93:43]
+    |   |--RPAREN -> ) [93:44]
+    |   `--SLIST -> { [93:46]
+    |       `--RCURLY -> } [93:47]
+    |--INSTANCE_INIT -> INSTANCE_INIT [96:4]
+    |   `--SLIST -> { [96:4]
+    |       `--RCURLY -> } [96:5]
+    |--SEMI -> ; [97:4]
+    |--METHOD_DEF -> METHOD_DEF [100:4]
+    |   |--MODIFIERS -> MODIFIERS [100:4]
+    |   |   `--LITERAL_PUBLIC -> public [100:4]
+    |   |--TYPE -> TYPE [100:11]
+    |   |   `--LITERAL_VOID -> void [100:11]
+    |   |--IDENT -> instructions [100:16]
+    |   |--LPAREN -> ( [100:28]
+    |   |--PARAMETERS -> PARAMETERS [100:29]
+    |   |--RPAREN -> ) [100:29]
+    |   |--LITERAL_THROWS -> throws [100:31]
+    |   |   `--IDENT -> Exception [100:38]
+    |   `--SLIST -> { [100:48]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [102:8]
+    |       |   |--MODIFIERS -> MODIFIERS [102:8]
+    |       |   |--TYPE -> TYPE [102:8]
+    |       |   |   `--LITERAL_BOOLEAN -> boolean [102:8]
+    |       |   |--IDENT -> b [102:16]
+    |       |   `--ASSIGN -> = [102:18]
+    |       |       `--EXPR -> EXPR [102:34]
+    |       |           `--GT -> > [102:34]
+    |       |               |--METHOD_CALL -> ( [102:31]
+    |       |               |   |--DOT -> . [102:24]
+    |       |               |   |   |--IDENT -> Math [102:20]
+    |       |               |   |   `--IDENT -> random [102:25]
+    |       |               |   |--ELIST -> ELIST [102:32]
+    |       |               |   `--RPAREN -> ) [102:32]
+    |       |               `--NUM_INT -> 0 [102:36]
+    |       |--SEMI -> ; [102:37]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [105:8]
+    |       |   |--MODIFIERS -> MODIFIERS [105:8]
+    |       |   |--TYPE -> TYPE [105:8]
+    |       |   |   `--LITERAL_BYTE -> byte [105:8]
+    |       |   `--IDENT -> vbyte [105:13]
+    |       |--SEMI -> ; [105:18]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [106:8]
+    |       |   |--MODIFIERS -> MODIFIERS [106:8]
+    |       |   |--TYPE -> TYPE [106:8]
+    |       |   |   `--LITERAL_BOOLEAN -> boolean [106:8]
+    |       |   `--IDENT -> vboolean [106:16]
+    |       |--SEMI -> ; [106:24]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [107:8]
+    |       |   |--MODIFIERS -> MODIFIERS [107:8]
+    |       |   |--TYPE -> TYPE [107:8]
+    |       |   |   `--LITERAL_CHAR -> char [107:8]
+    |       |   `--IDENT -> vchar [107:13]
+    |       |--SEMI -> ; [107:18]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [108:8]
+    |       |   |--MODIFIERS -> MODIFIERS [108:8]
+    |       |   |--TYPE -> TYPE [108:8]
+    |       |   |   `--LITERAL_SHORT -> short [108:8]
+    |       |   `--IDENT -> vshort [108:14]
+    |       |--SEMI -> ; [108:20]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [109:8]
+    |       |   |--MODIFIERS -> MODIFIERS [109:8]
+    |       |   |--TYPE -> TYPE [109:8]
+    |       |   |   `--LITERAL_INT -> int [109:8]
+    |       |   `--IDENT -> vint [109:12]
+    |       |--SEMI -> ; [109:16]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [110:8]
+    |       |   |--MODIFIERS -> MODIFIERS [110:8]
+    |       |   |--TYPE -> TYPE [110:8]
+    |       |   |   `--LITERAL_LONG -> long [110:8]
+    |       |   `--IDENT -> vlong [110:13]
+    |       |--SEMI -> ; [110:18]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [111:8]
+    |       |   |--MODIFIERS -> MODIFIERS [111:8]
+    |       |   |--TYPE -> TYPE [111:8]
+    |       |   |   `--LITERAL_FLOAT -> float [111:8]
+    |       |   `--IDENT -> vfloat [111:14]
+    |       |--SEMI -> ; [111:20]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [112:8]
+    |       |   |--MODIFIERS -> MODIFIERS [112:8]
+    |       |   |--TYPE -> TYPE [112:8]
+    |       |   |   `--LITERAL_DOUBLE -> double [112:8]
+    |       |   `--IDENT -> vdouble [112:15]
+    |       |--SEMI -> ; [112:22]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [113:8]
+    |       |   |--MODIFIERS -> MODIFIERS [113:8]
+    |       |   |--TYPE -> TYPE [113:8]
+    |       |   |   |--LITERAL_INT -> int [113:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [113:11]
+    |       |   |       `--RBRACK -> ] [113:12]
+    |       |   `--IDENT -> varray [113:14]
+    |       |--SEMI -> ; [113:20]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [114:8]
+    |       |   |--MODIFIERS -> MODIFIERS [114:8]
+    |       |   |--TYPE -> TYPE [114:8]
+    |       |   |   |--LITERAL_INT -> int [114:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [114:19]
+    |       |   |       `--RBRACK -> ] [114:20]
+    |       |   `--IDENT -> varray2 [114:12]
+    |       |--SEMI -> ; [114:21]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [115:8]
+    |       |   |--MODIFIERS -> MODIFIERS [115:8]
+    |       |   |--TYPE -> TYPE [115:8]
+    |       |   |   `--LITERAL_BOOLEAN -> boolean [115:8]
+    |       |   |--IDENT -> test1 [115:16]
+    |       |   `--ASSIGN -> = [115:22]
+    |       |       `--EXPR -> EXPR [115:24]
+    |       |           `--LITERAL_TRUE -> true [115:24]
+    |       |--SEMI -> ; [115:28]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [118:8]
+    |       |   |--MODIFIERS -> MODIFIERS [118:8]
+    |       |   |--TYPE -> TYPE [118:8]
+    |       |   |   `--IDENT -> String [118:8]
+    |       |   `--IDENT -> vstring [118:15]
+    |       |--SEMI -> ; [118:22]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [119:8]
+    |       |   |--MODIFIERS -> MODIFIERS [119:8]
+    |       |   |--TYPE -> TYPE [119:8]
+    |       |   |   |--IDENT -> List [119:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [119:12]
+    |       |   |       |--GENERIC_START -> < [119:12]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [119:13]
+    |       |   |       |   `--IDENT -> String [119:13]
+    |       |   |       `--GENERIC_END -> > [119:19]
+    |       |   `--IDENT -> vlist [119:21]
+    |       |--SEMI -> ; [119:26]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [120:8]
+    |       |   |--MODIFIERS -> MODIFIERS [120:8]
+    |       |   |--TYPE -> TYPE [120:8]
+    |       |   |   |--IDENT -> Map [120:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [120:11]
+    |       |   |       |--GENERIC_START -> < [120:11]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [120:12]
+    |       |   |       |   `--IDENT -> String [120:12]
+    |       |   |       |--COMMA -> , [120:18]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [120:20]
+    |       |   |       |   |--IDENT -> String [120:20]
+    |       |   |       |   `--ARRAY_DECLARATOR -> [ [120:26]
+    |       |   |       |       `--RBRACK -> ] [120:27]
+    |       |   |       `--GENERIC_END -> > [120:28]
+    |       |   `--IDENT -> vmap [120:30]
+    |       |--SEMI -> ; [120:34]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [121:8]
+    |       |   |--MODIFIERS -> MODIFIERS [121:8]
+    |       |   |--TYPE -> TYPE [121:8]
+    |       |   |   |--LITERAL_INT -> int [121:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [121:11]
+    |       |   |       `--RBRACK -> ] [121:12]
+    |       |   |--IDENT -> test2 [121:14]
+    |       |   `--ASSIGN -> = [121:20]
+    |       |       `--ARRAY_INIT -> { [121:22]
+    |       |           `--RCURLY -> } [121:23]
+    |       |--SEMI -> ; [121:24]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [122:8]
+    |       |   |--MODIFIERS -> MODIFIERS [122:8]
+    |       |   |--TYPE -> TYPE [122:8]
+    |       |   |   |--IDENT -> List [122:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [122:12]
+    |       |   |       |--GENERIC_START -> < [122:12]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [122:13]
+    |       |   |       |   |--LITERAL_CHAR -> char [122:13]
+    |       |   |       |   `--ARRAY_DECLARATOR -> [ [122:17]
+    |       |   |       |       `--RBRACK -> ] [122:18]
+    |       |   |       `--GENERIC_END -> > [122:19]
+    |       |   `--IDENT -> test3 [122:21]
+    |       |--SEMI -> ; [122:26]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [123:8]
+    |       |   |--MODIFIERS -> MODIFIERS [123:8]
+    |       |   |--TYPE -> TYPE [123:8]
+    |       |   |   |--IDENT -> Class [123:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [123:13]
+    |       |   |       |--GENERIC_START -> < [123:13]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [123:14]
+    |       |   |       |   `--WILDCARD_TYPE -> ? [123:14]
+    |       |   |       `--GENERIC_END -> > [123:15]
+    |       |   `--IDENT -> test4 [123:17]
+    |       |--SEMI -> ; [123:22]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [124:8]
+    |       |   |--MODIFIERS -> MODIFIERS [124:8]
+    |       |   |--TYPE -> TYPE [124:8]
+    |       |   |   |--IDENT -> List [124:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [124:12]
+    |       |   |       |--GENERIC_START -> < [124:12]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [124:13]
+    |       |   |       |   |--WILDCARD_TYPE -> ? [124:13]
+    |       |   |       |   `--TYPE_UPPER_BOUNDS -> extends [124:15]
+    |       |   |       |       `--IDENT -> InputRegressionJavaClass1 [124:23]
+    |       |   |       `--GENERIC_END -> > [124:48]
+    |       |   `--IDENT -> test5 [124:50]
+    |       |--SEMI -> ; [124:55]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [125:8]
+    |       |   |--MODIFIERS -> MODIFIERS [125:8]
+    |       |   |--TYPE -> TYPE [125:8]
+    |       |   |   |--IDENT -> List [125:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [125:12]
+    |       |   |       |--GENERIC_START -> < [125:12]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [125:13]
+    |       |   |       |   |--WILDCARD_TYPE -> ? [125:13]
+    |       |   |       |   `--TYPE_UPPER_BOUNDS -> extends [125:15]
+    |       |   |       |       |--IDENT -> List [125:23]
+    |       |   |       |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [125:27]
+    |       |   |       |           |--GENERIC_START -> < [125:27]
+    |       |   |       |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [125:28]
+    |       |   |       |           |   `--IDENT -> Object [125:28]
+    |       |   |       |           `--GENERIC_END -> > [125:34]
+    |       |   |       `--GENERIC_END -> > [125:35]
+    |       |   `--IDENT -> test6 [125:37]
+    |       |--SEMI -> ; [125:42]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [126:8]
+    |       |   |--MODIFIERS -> MODIFIERS [126:8]
+    |       |   |--TYPE -> TYPE [126:8]
+    |       |   |   |--IDENT -> List [126:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [126:12]
+    |       |   |       |--GENERIC_START -> < [126:12]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [126:13]
+    |       |   |       |   |--WILDCARD_TYPE -> ? [126:13]
+    |       |   |       |   `--TYPE_UPPER_BOUNDS -> extends [126:15]
+    |       |   |       |       |--IDENT -> List [126:23]
+    |       |   |       |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [126:27]
+    |       |   |       |           |--GENERIC_START -> < [126:27]
+    |       |   |       |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [126:28]
+    |       |   |       |           |   |--IDENT -> List [126:28]
+    |       |   |       |           |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [126:32]
+    |       |   |       |           |       |--GENERIC_START -> < [126:32]
+    |       |   |       |           |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [126:33]
+    |       |   |       |           |       |   `--IDENT -> Object [126:33]
+    |       |   |       |           |       `--GENERIC_END -> > [126:39]
+    |       |   |       |           `--GENERIC_END -> > [126:40]
+    |       |   |       `--GENERIC_END -> > [126:41]
+    |       |   `--IDENT -> test7 [126:43]
+    |       |--SEMI -> ; [126:48]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [127:8]
+    |       |   |--MODIFIERS -> MODIFIERS [127:8]
+    |       |   |--TYPE -> TYPE [127:8]
+    |       |   |   |--IDENT -> List [127:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [127:12]
+    |       |   |       |--GENERIC_START -> < [127:12]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [127:13]
+    |       |   |       |   |--WILDCARD_TYPE -> ? [127:13]
+    |       |   |       |   `--TYPE_UPPER_BOUNDS -> extends [127:15]
+    |       |   |       |       |--LITERAL_INT -> int [127:23]
+    |       |   |       |       `--ARRAY_DECLARATOR -> [ [127:26]
+    |       |   |       |           `--RBRACK -> ] [127:27]
+    |       |   |       `--GENERIC_END -> > [127:28]
+    |       |   `--IDENT -> test8 [127:30]
+    |       |--SEMI -> ; [127:35]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [128:8]
+    |       |   |--MODIFIERS -> MODIFIERS [128:8]
+    |       |   |--TYPE -> TYPE [128:8]
+    |       |   |   |--IDENT -> List [128:8]
+    |       |   |   `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [128:12]
+    |       |   |       |--GENERIC_START -> < [128:12]
+    |       |   |       |--TYPE_ARGUMENT -> TYPE_ARGUMENT [128:13]
+    |       |   |       |   |--WILDCARD_TYPE -> ? [128:13]
+    |       |   |       |   `--TYPE_LOWER_BOUNDS -> super [128:15]
+    |       |   |       |       `--IDENT -> InputRegressionJavaClass1 [128:21]
+    |       |   |       `--GENERIC_END -> > [128:46]
+    |       |   `--IDENT -> test9 [128:48]
+    |       |--SEMI -> ; [128:53]
+    |       |--EXPR -> EXPR [131:17]
+    |       |   `--ASSIGN -> = [131:17]
+    |       |       |--IDENT -> vboolean [131:8]
+    |       |       `--LITERAL_TRUE -> true [131:19]
+    |       |--SEMI -> ; [131:23]
+    |       |--EXPR -> EXPR [132:17]
+    |       |   `--ASSIGN -> = [132:17]
+    |       |       |--IDENT -> vboolean [132:8]
+    |       |       `--LITERAL_FALSE -> false [132:19]
+    |       |--SEMI -> ; [132:24]
+    |       |--EXPR -> EXPR [133:14]
+    |       |   `--ASSIGN -> = [133:14]
+    |       |       |--IDENT -> vchar [133:8]
+    |       |       `--CHAR_LITERAL -> ' ' [133:16]
+    |       |--SEMI -> ; [133:19]
+    |       |--EXPR -> EXPR [134:14]
+    |       |   `--ASSIGN -> = [134:14]
+    |       |       |--IDENT -> vchar [134:8]
+    |       |       `--CHAR_LITERAL -> '"' [134:16]
+    |       |--SEMI -> ; [134:19]
+    |       |--EXPR -> EXPR [135:14]
+    |       |   `--ASSIGN -> = [135:14]
+    |       |       |--IDENT -> vchar [135:8]
+    |       |       `--CHAR_LITERAL -> '\0' [135:16]
+    |       |--SEMI -> ; [135:20]
+    |       |--EXPR -> EXPR [136:14]
+    |       |   `--ASSIGN -> = [136:14]
+    |       |       |--IDENT -> vchar [136:8]
+    |       |       `--CHAR_LITERAL -> '\'' [136:16]
+    |       |--SEMI -> ; [136:20]
+    |       |--EXPR -> EXPR [137:14]
+    |       |   `--ASSIGN -> = [137:14]
+    |       |       |--IDENT -> vchar [137:8]
+    |       |       `--CHAR_LITERAL -> '\n' [137:16]
+    |       |--SEMI -> ; [137:20]
+    |       |--EXPR -> EXPR [138:14]
+    |       |   `--ASSIGN -> = [138:14]
+    |       |       |--IDENT -> vchar [138:8]
+    |       |       `--CHAR_LITERAL -> '\r' [138:16]
+    |       |--SEMI -> ; [138:20]
+    |       |--EXPR -> EXPR [139:14]
+    |       |   `--ASSIGN -> = [139:14]
+    |       |       |--IDENT -> vchar [139:8]
+    |       |       `--CHAR_LITERAL -> '\t' [139:16]
+    |       |--SEMI -> ; [139:20]
+    |       |--EXPR -> EXPR [140:14]
+    |       |   `--ASSIGN -> = [140:14]
+    |       |       |--IDENT -> vchar [140:8]
+    |       |       `--CHAR_LITERAL -> '\b' [140:16]
+    |       |--SEMI -> ; [140:20]
+    |       |--EXPR -> EXPR [141:14]
+    |       |   `--ASSIGN -> = [141:14]
+    |       |       |--IDENT -> vchar [141:8]
+    |       |       `--CHAR_LITERAL -> '\f' [141:16]
+    |       |--SEMI -> ; [141:20]
+    |       |--EXPR -> EXPR [142:14]
+    |       |   `--ASSIGN -> = [142:14]
+    |       |       |--IDENT -> vchar [142:8]
+    |       |       `--CHAR_LITERAL -> '\"' [142:16]
+    |       |--SEMI -> ; [142:20]
+    |       |--EXPR -> EXPR [143:14]
+    |       |   `--ASSIGN -> = [143:14]
+    |       |       |--IDENT -> vchar [143:8]
+    |       |       `--CHAR_LITERAL -> '\'' [143:16]
+    |       |--SEMI -> ; [143:20]
+    |       |--EXPR -> EXPR [144:14]
+    |       |   `--ASSIGN -> = [144:14]
+    |       |       |--IDENT -> vchar [144:8]
+    |       |       `--CHAR_LITERAL -> '\\' [144:16]
+    |       |--SEMI -> ; [144:20]
+    |       |--EXPR -> EXPR [145:14]
+    |       |   `--ASSIGN -> = [145:14]
+    |       |       |--IDENT -> vchar [145:8]
+    |       |       `--CHAR_LITERAL -> '\00' [145:16]
+    |       |--SEMI -> ; [145:21]
+    |       |--EXPR -> EXPR [146:14]
+    |       |   `--ASSIGN -> = [146:14]
+    |       |       |--IDENT -> vchar [146:8]
+    |       |       `--CHAR_LITERAL -> '\013' [146:16]
+    |       |--SEMI -> ; [146:22]
+    |       |--EXPR -> EXPR [147:14]
+    |       |   `--ASSIGN -> = [147:14]
+    |       |       |--IDENT -> vchar [147:8]
+    |       |       `--CHAR_LITERAL -> '\4' [147:16]
+    |       |--SEMI -> ; [147:20]
+    |       |--EXPR -> EXPR [148:14]
+    |       |   `--ASSIGN -> = [148:14]
+    |       |       |--IDENT -> vchar [148:8]
+    |       |       `--CHAR_LITERAL -> '\40' [148:16]
+    |       |--SEMI -> ; [148:21]
+    |       |--EXPR -> EXPR [149:14]
+    |       |   `--ASSIGN -> = [149:14]
+    |       |       |--IDENT -> vchar [149:8]
+    |       |       `--CHAR_LITERAL -> '\u0000' [149:16]
+    |       |--SEMI -> ; [149:24]
+    |       |--EXPR -> EXPR [150:14]
+    |       |   `--ASSIGN -> = [150:14]
+    |       |       |--IDENT -> vchar [150:8]
+    |       |       `--CHAR_LITERAL -> '\u1234' [150:16]
+    |       |--SEMI -> ; [150:24]
+    |       |--EXPR -> EXPR [151:14]
+    |       |   `--ASSIGN -> = [151:14]
+    |       |       |--IDENT -> vchar [151:8]
+    |       |       `--CHAR_LITERAL -> '\u005C\u005C' [151:16]
+    |       |--SEMI -> ; [151:30]
+    |       |--EXPR -> EXPR [152:14]
+    |       |   `--ASSIGN -> = [152:14]
+    |       |       |--IDENT -> vchar [152:8]
+    |       |       `--CHAR_LITERAL -> '\u005c\u005c' [152:16]
+    |       |--SEMI -> ; [152:30]
+    |       |--EXPR -> EXPR [153:14]
+    |       |   `--ASSIGN -> = [153:14]
+    |       |       |--IDENT -> vchar [153:8]
+    |       |       `--CHAR_LITERAL -> '\uu005C\uuuuu005C' [153:16]
+    |       |--SEMI -> ; [153:35]
+    |       |--EXPR -> EXPR [154:14]
+    |       |   `--ASSIGN -> = [154:14]
+    |       |       |--IDENT -> vchar [154:8]
+    |       |       `--CHAR_LITERAL -> '\u005cn' [154:16]
+    |       |--SEMI -> ; [154:25]
+    |       |--EXPR -> EXPR [155:14]
+    |       |   `--ASSIGN -> = [155:14]
+    |       |       |--IDENT -> vchar [155:8]
+    |       |       `--CHAR_LITERAL -> '\u005cr' [155:16]
+    |       |--SEMI -> ; [155:25]
+    |       |--EXPR -> EXPR [156:14]
+    |       |   `--ASSIGN -> = [156:14]
+    |       |       |--IDENT -> vchar [156:8]
+    |       |       `--CHAR_LITERAL -> '\u005ct' [156:16]
+    |       |--SEMI -> ; [156:25]
+    |       |--EXPR -> EXPR [157:14]
+    |       |   `--ASSIGN -> = [157:14]
+    |       |       |--IDENT -> vchar [157:8]
+    |       |       `--CHAR_LITERAL -> '\u005cb' [157:16]
+    |       |--SEMI -> ; [157:25]
+    |       |--EXPR -> EXPR [158:14]
+    |       |   `--ASSIGN -> = [158:14]
+    |       |       |--IDENT -> vchar [158:8]
+    |       |       `--CHAR_LITERAL -> '\u005cf' [158:16]
+    |       |--SEMI -> ; [158:25]
+    |       |--EXPR -> EXPR [159:14]
+    |       |   `--ASSIGN -> = [159:14]
+    |       |       |--IDENT -> vchar [159:8]
+    |       |       `--CHAR_LITERAL -> '\u005c"' [159:16]
+    |       |--SEMI -> ; [159:25]
+    |       |--EXPR -> EXPR [160:14]
+    |       |   `--ASSIGN -> = [160:14]
+    |       |       |--IDENT -> vchar [160:8]
+    |       |       `--CHAR_LITERAL -> '\u005c'' [160:16]
+    |       |--SEMI -> ; [160:25]
+    |       |--EXPR -> EXPR [161:14]
+    |       |   `--ASSIGN -> = [161:14]
+    |       |       |--IDENT -> vchar [161:8]
+    |       |       `--CHAR_LITERAL -> '\u005c\' [161:16]
+    |       |--SEMI -> ; [161:25]
+    |       |--EXPR -> EXPR [162:13]
+    |       |   `--ASSIGN -> = [162:13]
+    |       |       |--IDENT -> vint [162:8]
+    |       |       `--NUM_INT -> 0 [162:15]
+    |       |--SEMI -> ; [162:16]
+    |       |--EXPR -> EXPR [163:13]
+    |       |   `--ASSIGN -> = [163:13]
+    |       |       |--IDENT -> vint [163:8]
+    |       |       `--UNARY_MINUS -> - [163:15]
+    |       |           `--NUM_INT -> 1 [163:16]
+    |       |--SEMI -> ; [163:17]
+    |       |--EXPR -> EXPR [164:13]
+    |       |   `--ASSIGN -> = [164:13]
+    |       |       |--IDENT -> vint [164:8]
+    |       |       `--UNARY_PLUS -> + [164:15]
+    |       |           `--NUM_INT -> 1 [164:16]
+    |       |--SEMI -> ; [164:17]
+    |       |--EXPR -> EXPR [165:13]
+    |       |   `--ASSIGN -> = [165:13]
+    |       |       |--IDENT -> vint [165:8]
+    |       |       `--NUM_INT -> 100_000 [165:15]
+    |       |--SEMI -> ; [165:22]
+    |       |--EXPR -> EXPR [166:13]
+    |       |   `--ASSIGN -> = [166:13]
+    |       |       |--IDENT -> vint [166:8]
+    |       |       `--NUM_INT -> 0x00 [166:15]
+    |       |--SEMI -> ; [166:19]
+    |       |--EXPR -> EXPR [167:13]
+    |       |   `--ASSIGN -> = [167:13]
+    |       |       |--IDENT -> vint [167:8]
+    |       |       `--NUM_INT -> 0x12345678 [167:15]
+    |       |--SEMI -> ; [167:25]
+    |       |--EXPR -> EXPR [168:13]
+    |       |   `--ASSIGN -> = [168:13]
+    |       |       |--IDENT -> vint [168:8]
+    |       |       `--NUM_INT -> 0X9 [168:15]
+    |       |--SEMI -> ; [168:18]
+    |       |--EXPR -> EXPR [169:13]
+    |       |   `--ASSIGN -> = [169:13]
+    |       |       |--IDENT -> vint [169:8]
+    |       |       `--NUM_INT -> 0x1234_5678 [169:15]
+    |       |--SEMI -> ; [169:26]
+    |       |--EXPR -> EXPR [170:13]
+    |       |   `--ASSIGN -> = [170:13]
+    |       |       |--IDENT -> vint [170:8]
+    |       |       `--NUM_INT -> 0b101 [170:15]
+    |       |--SEMI -> ; [170:20]
+    |       |--EXPR -> EXPR [171:13]
+    |       |   `--ASSIGN -> = [171:13]
+    |       |       |--IDENT -> vint [171:8]
+    |       |       `--NUM_INT -> 0B101 [171:15]
+    |       |--SEMI -> ; [171:20]
+    |       |--EXPR -> EXPR [172:13]
+    |       |   `--ASSIGN -> = [172:13]
+    |       |       |--IDENT -> vint [172:8]
+    |       |       `--NUM_INT -> 0b1 [172:15]
+    |       |--SEMI -> ; [172:18]
+    |       |--EXPR -> EXPR [173:13]
+    |       |   `--ASSIGN -> = [173:13]
+    |       |       |--IDENT -> vint [173:8]
+    |       |       `--NUM_INT -> 0b1_0 [173:15]
+    |       |--SEMI -> ; [173:20]
+    |       |--EXPR -> EXPR [174:13]
+    |       |   `--ASSIGN -> = [174:13]
+    |       |       |--IDENT -> vint [174:8]
+    |       |       `--NUM_INT -> 012345670 [174:15]
+    |       |--SEMI -> ; [174:24]
+    |       |--EXPR -> EXPR [175:13]
+    |       |   `--ASSIGN -> = [175:13]
+    |       |       |--IDENT -> vint [175:8]
+    |       |       `--NUM_INT -> 01234_5670 [175:15]
+    |       |--SEMI -> ; [175:25]
+    |       |--EXPR -> EXPR [176:14]
+    |       |   `--ASSIGN -> = [176:14]
+    |       |       |--IDENT -> vlong [176:8]
+    |       |       `--NUM_LONG -> 0L [176:16]
+    |       |--SEMI -> ; [176:18]
+    |       |--EXPR -> EXPR [177:14]
+    |       |   `--ASSIGN -> = [177:14]
+    |       |       |--IDENT -> vlong [177:8]
+    |       |       `--NUM_LONG -> 1L [177:16]
+    |       |--SEMI -> ; [177:18]
+    |       |--EXPR -> EXPR [178:14]
+    |       |   `--ASSIGN -> = [178:14]
+    |       |       |--IDENT -> vlong [178:8]
+    |       |       `--NUM_LONG -> 0b1L [178:16]
+    |       |--SEMI -> ; [178:20]
+    |       |--EXPR -> EXPR [179:14]
+    |       |   `--ASSIGN -> = [179:14]
+    |       |       |--IDENT -> vlong [179:8]
+    |       |       `--NUM_LONG -> 1234567890l [179:16]
+    |       |--SEMI -> ; [179:27]
+    |       |--EXPR -> EXPR [180:14]
+    |       |   `--ASSIGN -> = [180:14]
+    |       |       |--IDENT -> vlong [180:8]
+    |       |       `--NUM_LONG -> 1234567890L [180:16]
+    |       |--SEMI -> ; [180:27]
+    |       |--EXPR -> EXPR [181:14]
+    |       |   `--ASSIGN -> = [181:14]
+    |       |       |--IDENT -> vlong [181:8]
+    |       |       `--NUM_LONG -> 0x0l [181:16]
+    |       |--SEMI -> ; [181:20]
+    |       |--EXPR -> EXPR [182:14]
+    |       |   `--ASSIGN -> = [182:14]
+    |       |       |--IDENT -> vlong [182:8]
+    |       |       `--NUM_LONG -> 0xABCDEFl [182:16]
+    |       |--SEMI -> ; [182:25]
+    |       |--EXPR -> EXPR [183:14]
+    |       |   `--ASSIGN -> = [183:14]
+    |       |       |--IDENT -> vlong [183:8]
+    |       |       `--NUM_LONG -> 0XABCDEFL [183:16]
+    |       |--SEMI -> ; [183:25]
+    |       |--EXPR -> EXPR [184:15]
+    |       |   `--ASSIGN -> = [184:15]
+    |       |       |--IDENT -> vfloat [184:8]
+    |       |       `--NUM_FLOAT -> 0f [184:17]
+    |       |--SEMI -> ; [184:19]
+    |       |--EXPR -> EXPR [185:15]
+    |       |   `--ASSIGN -> = [185:15]
+    |       |       |--IDENT -> vfloat [185:8]
+    |       |       `--NUM_FLOAT -> 0F [185:17]
+    |       |--SEMI -> ; [185:19]
+    |       |--EXPR -> EXPR [186:15]
+    |       |   `--ASSIGN -> = [186:15]
+    |       |       |--IDENT -> vfloat [186:8]
+    |       |       `--NUM_FLOAT -> 1.1f [186:17]
+    |       |--SEMI -> ; [186:21]
+    |       |--EXPR -> EXPR [187:15]
+    |       |   `--ASSIGN -> = [187:15]
+    |       |       |--IDENT -> vfloat [187:8]
+    |       |       `--NUM_FLOAT -> 1.10_1F [187:17]
+    |       |--SEMI -> ; [187:24]
+    |       |--EXPR -> EXPR [188:15]
+    |       |   `--ASSIGN -> = [188:15]
+    |       |       |--IDENT -> vfloat [188:8]
+    |       |       `--NUM_FLOAT -> 0_1.1_1F [188:17]
+    |       |--SEMI -> ; [188:25]
+    |       |--EXPR -> EXPR [189:15]
+    |       |   `--ASSIGN -> = [189:15]
+    |       |       |--IDENT -> vfloat [189:8]
+    |       |       `--NUM_FLOAT -> 1e0f [189:17]
+    |       |--SEMI -> ; [189:21]
+    |       |--EXPR -> EXPR [190:15]
+    |       |   `--ASSIGN -> = [190:15]
+    |       |       |--IDENT -> vfloat [190:8]
+    |       |       `--NUM_FLOAT -> 1e0F [190:17]
+    |       |--SEMI -> ; [190:21]
+    |       |--EXPR -> EXPR [191:15]
+    |       |   `--ASSIGN -> = [191:15]
+    |       |       |--IDENT -> vfloat [191:8]
+    |       |       `--NUM_FLOAT -> 1.0e0F [191:17]
+    |       |--SEMI -> ; [191:23]
+    |       |--EXPR -> EXPR [192:15]
+    |       |   `--ASSIGN -> = [192:15]
+    |       |       |--IDENT -> vfloat [192:8]
+    |       |       `--NUM_FLOAT -> 0x2__3_34.4___AFP00_00f [192:17]
+    |       |--SEMI -> ; [192:40]
+    |       |--EXPR -> EXPR [193:16]
+    |       |   `--ASSIGN -> = [193:16]
+    |       |       |--IDENT -> vdouble [193:8]
+    |       |       `--NUM_FLOAT -> 10. [193:18]
+    |       |--SEMI -> ; [193:21]
+    |       |--EXPR -> EXPR [194:16]
+    |       |   `--ASSIGN -> = [194:16]
+    |       |       |--IDENT -> vdouble [194:8]
+    |       |       `--NUM_FLOAT -> .1 [194:18]
+    |       |--SEMI -> ; [194:20]
+    |       |--EXPR -> EXPR [195:16]
+    |       |   `--ASSIGN -> = [195:16]
+    |       |       |--IDENT -> vdouble [195:8]
+    |       |       `--NUM_FLOAT -> .1__1_1 [195:18]
+    |       |--SEMI -> ; [195:25]
+    |       |--EXPR -> EXPR [196:16]
+    |       |   `--ASSIGN -> = [196:16]
+    |       |       |--IDENT -> vdouble [196:8]
+    |       |       `--NUM_FLOAT -> 0.0 [196:18]
+    |       |--SEMI -> ; [196:21]
+    |       |--EXPR -> EXPR [197:16]
+    |       |   `--ASSIGN -> = [197:16]
+    |       |       |--IDENT -> vdouble [197:8]
+    |       |       `--NUM_FLOAT -> 1000.0 [197:18]
+    |       |--SEMI -> ; [197:24]
+    |       |--EXPR -> EXPR [198:16]
+    |       |   `--ASSIGN -> = [198:16]
+    |       |       |--IDENT -> vdouble [198:8]
+    |       |       `--NUM_DOUBLE -> .1d [198:18]
+    |       |--SEMI -> ; [198:21]
+    |       |--EXPR -> EXPR [199:16]
+    |       |   `--ASSIGN -> = [199:16]
+    |       |       |--IDENT -> vdouble [199:8]
+    |       |       `--NUM_DOUBLE -> 1.D [199:18]
+    |       |--SEMI -> ; [199:21]
+    |       |--EXPR -> EXPR [200:16]
+    |       |   `--ASSIGN -> = [200:16]
+    |       |       |--IDENT -> vdouble [200:8]
+    |       |       `--NUM_DOUBLE -> 0_1.0d [200:18]
+    |       |--SEMI -> ; [200:24]
+    |       |--EXPR -> EXPR [201:16]
+    |       |   `--ASSIGN -> = [201:16]
+    |       |       |--IDENT -> vdouble [201:8]
+    |       |       `--NUM_DOUBLE -> 0_1.0D [201:18]
+    |       |--SEMI -> ; [201:24]
+    |       |--EXPR -> EXPR [202:16]
+    |       |   `--ASSIGN -> = [202:16]
+    |       |       |--IDENT -> vdouble [202:8]
+    |       |       `--NUM_FLOAT -> 4e23 [202:18]
+    |       |--SEMI -> ; [202:22]
+    |       |--EXPR -> EXPR [203:16]
+    |       |   `--ASSIGN -> = [203:16]
+    |       |       |--IDENT -> vdouble [203:8]
+    |       |       `--NUM_FLOAT -> 4E23 [203:18]
+    |       |--SEMI -> ; [203:22]
+    |       |--EXPR -> EXPR [204:16]
+    |       |   `--ASSIGN -> = [204:16]
+    |       |       |--IDENT -> vdouble [204:8]
+    |       |       `--NUM_FLOAT -> 4E2_3 [204:18]
+    |       |--SEMI -> ; [204:23]
+    |       |--EXPR -> EXPR [205:16]
+    |       |   `--ASSIGN -> = [205:16]
+    |       |       |--IDENT -> vdouble [205:8]
+    |       |       `--NUM_FLOAT -> 0x0.0000000000001p-1022 [205:18]
+    |       |--SEMI -> ; [205:41]
+    |       |--EXPR -> EXPR [206:16]
+    |       |   `--ASSIGN -> = [206:16]
+    |       |       |--IDENT -> vdouble [206:8]
+    |       |       `--NUM_FLOAT -> 0x0.0000000000001P-1022 [206:18]
+    |       |--SEMI -> ; [206:41]
+    |       |--EXPR -> EXPR [207:16]
+    |       |   `--ASSIGN -> = [207:16]
+    |       |       |--IDENT -> vdouble [207:8]
+    |       |       `--NUM_FLOAT -> 0X0.0000000000001p+1022 [207:18]
+    |       |--SEMI -> ; [207:41]
+    |       |--EXPR -> EXPR [208:16]
+    |       |   `--ASSIGN -> = [208:16]
+    |       |       |--IDENT -> vdouble [208:8]
+    |       |       `--NUM_FLOAT -> 0X0.0000000000001P+1022 [208:18]
+    |       |--SEMI -> ; [208:41]
+    |       |--EXPR -> EXPR [209:16]
+    |       |   `--ASSIGN -> = [209:16]
+    |       |       |--IDENT -> vdouble [209:8]
+    |       |       `--NUM_FLOAT -> 0x.0P0 [209:18]
+    |       |--SEMI -> ; [209:24]
+    |       |--EXPR -> EXPR [210:16]
+    |       |   `--ASSIGN -> = [210:16]
+    |       |       |--IDENT -> vdouble [210:8]
+    |       |       `--NUM_FLOAT -> 0X0p+2 [210:18]
+    |       |--SEMI -> ; [210:24]
+    |       |--EXPR -> EXPR [211:16]
+    |       |   `--ASSIGN -> = [211:16]
+    |       |       |--IDENT -> vdouble [211:8]
+    |       |       `--NUM_FLOAT -> 0X0p+20F [211:18]
+    |       |--SEMI -> ; [211:26]
+    |       |--EXPR -> EXPR [212:16]
+    |       |   `--ASSIGN -> = [212:16]
+    |       |       |--IDENT -> vdouble [212:8]
+    |       |       `--NUM_DOUBLE -> 0X0p+2D [212:18]
+    |       |--SEMI -> ; [212:25]
+    |       |--EXPR -> EXPR [213:16]
+    |       |   `--ASSIGN -> = [213:16]
+    |       |       |--IDENT -> vdouble [213:8]
+    |       |       `--NUM_DOUBLE -> 0X0p+2d [213:18]
+    |       |--SEMI -> ; [213:25]
+    |       |--EXPR -> EXPR [214:16]
+    |       |   `--ASSIGN -> = [214:16]
+    |       |       |--IDENT -> vdouble [214:8]
+    |       |       `--NUM_FLOAT -> 0x1.P-1 [214:18]
+    |       |--SEMI -> ; [214:25]
+    |       |--EXPR -> EXPR [215:16]
+    |       |   `--ASSIGN -> = [215:16]
+    |       |       |--IDENT -> vdouble [215:8]
+    |       |       `--NUM_FLOAT -> 0x.1___AFp1 [215:18]
+    |       |--SEMI -> ; [215:29]
+    |       |--EXPR -> EXPR [216:16]
+    |       |   `--ASSIGN -> = [216:16]
+    |       |       |--IDENT -> vstring [216:8]
+    |       |       `--LITERAL_NULL -> null [216:18]
+    |       |--SEMI -> ; [216:22]
+    |       |--EXPR -> EXPR [217:16]
+    |       |   `--ASSIGN -> = [217:16]
+    |       |       |--IDENT -> vstring [217:8]
+    |       |       `--STRING_LITERAL -> "" [217:18]
+    |       |--SEMI -> ; [217:20]
+    |       |--EXPR -> EXPR [218:16]
+    |       |   `--ASSIGN -> = [218:16]
+    |       |       |--IDENT -> vstring [218:8]
+    |       |       `--STRING_LITERAL -> "\\" [218:18]
+    |       |--SEMI -> ; [218:22]
+    |       |--EXPR -> EXPR [221:13]
+    |       |   `--ASSIGN -> = [221:13]
+    |       |       |--IDENT -> vint [221:8]
+    |       |       `--PLUS -> + [221:17]
+    |       |           |--NUM_INT -> 1 [221:15]
+    |       |           `--NUM_INT -> 1 [221:19]
+    |       |--SEMI -> ; [221:20]
+    |       |--EXPR -> EXPR [222:13]
+    |       |   `--ASSIGN -> = [222:13]
+    |       |       |--IDENT -> vint [222:8]
+    |       |       `--MINUS -> - [222:17]
+    |       |           |--NUM_INT -> 1 [222:15]
+    |       |           `--NUM_INT -> 1 [222:19]
+    |       |--SEMI -> ; [222:20]
+    |       |--EXPR -> EXPR [223:13]
+    |       |   `--ASSIGN -> = [223:13]
+    |       |       |--IDENT -> vint [223:8]
+    |       |       `--STAR -> * [223:17]
+    |       |           |--NUM_INT -> 1 [223:15]
+    |       |           `--NUM_INT -> 1 [223:19]
+    |       |--SEMI -> ; [223:20]
+    |       |--EXPR -> EXPR [224:13]
+    |       |   `--ASSIGN -> = [224:13]
+    |       |       |--IDENT -> vint [224:8]
+    |       |       `--DIV -> / [224:17]
+    |       |           |--NUM_INT -> 1 [224:15]
+    |       |           `--NUM_INT -> 1 [224:19]
+    |       |--SEMI -> ; [224:20]
+    |       |--EXPR -> EXPR [225:13]
+    |       |   `--ASSIGN -> = [225:13]
+    |       |       |--IDENT -> vint [225:8]
+    |       |       `--MOD -> % [225:17]
+    |       |           |--NUM_INT -> 1 [225:15]
+    |       |           `--NUM_INT -> 1 [225:19]
+    |       |--SEMI -> ; [225:20]
+    |       |--EXPR -> EXPR [226:13]
+    |       |   `--ASSIGN -> = [226:13]
+    |       |       |--IDENT -> vint [226:8]
+    |       |       `--BAND -> & [226:17]
+    |       |           |--NUM_INT -> 1 [226:15]
+    |       |           `--NUM_INT -> 1 [226:19]
+    |       |--SEMI -> ; [226:20]
+    |       |--EXPR -> EXPR [227:13]
+    |       |   `--ASSIGN -> = [227:13]
+    |       |       |--IDENT -> vint [227:8]
+    |       |       `--BOR -> | [227:17]
+    |       |           |--NUM_INT -> 1 [227:15]
+    |       |           `--NUM_INT -> 1 [227:19]
+    |       |--SEMI -> ; [227:20]
+    |       |--EXPR -> EXPR [228:13]
+    |       |   `--ASSIGN -> = [228:13]
+    |       |       |--IDENT -> vint [228:8]
+    |       |       `--BXOR -> ^ [228:17]
+    |       |           |--NUM_INT -> 1 [228:15]
+    |       |           `--NUM_INT -> 1 [228:19]
+    |       |--SEMI -> ; [228:20]
+    |       |--EXPR -> EXPR [229:13]
+    |       |   `--ASSIGN -> = [229:13]
+    |       |       |--IDENT -> vint [229:8]
+    |       |       `--BNOT -> ~ [229:15]
+    |       |           `--NUM_INT -> 1 [229:16]
+    |       |--SEMI -> ; [229:17]
+    |       |--EXPR -> EXPR [230:17]
+    |       |   `--ASSIGN -> = [230:17]
+    |       |       |--IDENT -> vboolean [230:8]
+    |       |       `--NOT_EQUAL -> != [230:21]
+    |       |           |--NUM_INT -> 1 [230:19]
+    |       |           `--NUM_INT -> 0 [230:24]
+    |       |--SEMI -> ; [230:25]
+    |       |--EXPR -> EXPR [231:17]
+    |       |   `--ASSIGN -> = [231:17]
+    |       |       |--IDENT -> vboolean [231:8]
+    |       |       `--EQUAL -> == [231:21]
+    |       |           |--NUM_INT -> 1 [231:19]
+    |       |           `--NUM_INT -> 0 [231:24]
+    |       |--SEMI -> ; [231:25]
+    |       |--EXPR -> EXPR [232:17]
+    |       |   `--ASSIGN -> = [232:17]
+    |       |       |--IDENT -> vboolean [232:8]
+    |       |       `--GT -> > [232:21]
+    |       |           |--NUM_INT -> 1 [232:19]
+    |       |           `--NUM_INT -> 0 [232:23]
+    |       |--SEMI -> ; [232:24]
+    |       |--EXPR -> EXPR [233:17]
+    |       |   `--ASSIGN -> = [233:17]
+    |       |       |--IDENT -> vboolean [233:8]
+    |       |       `--GE -> >= [233:21]
+    |       |           |--NUM_INT -> 1 [233:19]
+    |       |           `--NUM_INT -> 0 [233:24]
+    |       |--SEMI -> ; [233:25]
+    |       |--EXPR -> EXPR [234:17]
+    |       |   `--ASSIGN -> = [234:17]
+    |       |       |--IDENT -> vboolean [234:8]
+    |       |       `--LT -> < [234:21]
+    |       |           |--NUM_INT -> 1 [234:19]
+    |       |           `--NUM_INT -> 0 [234:23]
+    |       |--SEMI -> ; [234:24]
+    |       |--EXPR -> EXPR [235:17]
+    |       |   `--ASSIGN -> = [235:17]
+    |       |       |--IDENT -> vboolean [235:8]
+    |       |       `--LE -> <= [235:21]
+    |       |           |--NUM_INT -> 1 [235:19]
+    |       |           `--NUM_INT -> 0 [235:24]
+    |       |--SEMI -> ; [235:25]
+    |       |--EXPR -> EXPR [236:17]
+    |       |   `--ASSIGN -> = [236:17]
+    |       |       |--IDENT -> vboolean [236:8]
+    |       |       `--LAND -> && [236:24]
+    |       |           |--LITERAL_TRUE -> true [236:19]
+    |       |           `--LITERAL_TRUE -> true [236:27]
+    |       |--SEMI -> ; [236:31]
+    |       |--EXPR -> EXPR [237:17]
+    |       |   `--ASSIGN -> = [237:17]
+    |       |       |--IDENT -> vboolean [237:8]
+    |       |       `--LOR -> || [237:24]
+    |       |           |--LITERAL_TRUE -> true [237:19]
+    |       |           `--LITERAL_TRUE -> true [237:27]
+    |       |--SEMI -> ; [237:31]
+    |       |--EXPR -> EXPR [238:17]
+    |       |   `--ASSIGN -> = [238:17]
+    |       |       |--IDENT -> vboolean [238:8]
+    |       |       `--QUESTION -> ? [238:24]
+    |       |           |--LITERAL_TRUE -> true [238:19]
+    |       |           |--LITERAL_TRUE -> true [238:26]
+    |       |           |--COLON -> : [238:31]
+    |       |           `--LITERAL_FALSE -> false [238:33]
+    |       |--SEMI -> ; [238:38]
+    |       |--EXPR -> EXPR [239:17]
+    |       |   `--ASSIGN -> = [239:17]
+    |       |       |--IDENT -> vboolean [239:8]
+    |       |       `--LNOT -> ! [239:19]
+    |       |           `--LITERAL_TRUE -> true [239:20]
+    |       |--SEMI -> ; [239:24]
+    |       |--EXPR -> EXPR [240:17]
+    |       |   `--ASSIGN -> = [240:17]
+    |       |       |--IDENT -> vboolean [240:8]
+    |       |       `--LITERAL_INSTANCEOF -> instanceof [240:22]
+    |       |           |--IDENT -> f9 [240:19]
+    |       |           `--TYPE -> TYPE [240:33]
+    |       |               `--IDENT -> Object [240:33]
+    |       |--SEMI -> ; [240:39]
+    |       |--EXPR -> EXPR [241:13]
+    |       |   `--ASSIGN -> = [241:13]
+    |       |       |--IDENT -> vint [241:8]
+    |       |       `--SL -> << [241:17]
+    |       |           |--NUM_INT -> 1 [241:15]
+    |       |           `--NUM_INT -> 1 [241:20]
+    |       |--SEMI -> ; [241:21]
+    |       |--EXPR -> EXPR [242:13]
+    |       |   `--ASSIGN -> = [242:13]
+    |       |       |--IDENT -> vint [242:8]
+    |       |       `--SR -> >> [242:17]
+    |       |           |--NUM_INT -> 1 [242:15]
+    |       |           `--NUM_INT -> 1 [242:20]
+    |       |--SEMI -> ; [242:21]
+    |       |--EXPR -> EXPR [243:13]
+    |       |   `--ASSIGN -> = [243:13]
+    |       |       |--IDENT -> vint [243:8]
+    |       |       `--BSR -> >>> [243:17]
+    |       |           |--NUM_INT -> 1 [243:15]
+    |       |           `--NUM_INT -> 1 [243:21]
+    |       |--SEMI -> ; [243:22]
+    |       |--EXPR -> EXPR [244:13]
+    |       |   `--PLUS_ASSIGN -> += [244:13]
+    |       |       |--IDENT -> vint [244:8]
+    |       |       `--NUM_INT -> 1 [244:16]
+    |       |--SEMI -> ; [244:17]
+    |       |--EXPR -> EXPR [245:13]
+    |       |   `--MINUS_ASSIGN -> -= [245:13]
+    |       |       |--IDENT -> vint [245:8]
+    |       |       `--NUM_INT -> 1 [245:16]
+    |       |--SEMI -> ; [245:17]
+    |       |--EXPR -> EXPR [246:13]
+    |       |   `--STAR_ASSIGN -> *= [246:13]
+    |       |       |--IDENT -> vint [246:8]
+    |       |       `--NUM_INT -> 1 [246:16]
+    |       |--SEMI -> ; [246:17]
+    |       |--EXPR -> EXPR [247:13]
+    |       |   `--DIV_ASSIGN -> /= [247:13]
+    |       |       |--IDENT -> vint [247:8]
+    |       |       `--NUM_INT -> 1 [247:16]
+    |       |--SEMI -> ; [247:17]
+    |       |--EXPR -> EXPR [248:13]
+    |       |   `--MOD_ASSIGN -> %= [248:13]
+    |       |       |--IDENT -> vint [248:8]
+    |       |       `--NUM_INT -> 1 [248:16]
+    |       |--SEMI -> ; [248:17]
+    |       |--EXPR -> EXPR [249:13]
+    |       |   `--BAND_ASSIGN -> &= [249:13]
+    |       |       |--IDENT -> vint [249:8]
+    |       |       `--NUM_INT -> 1 [249:16]
+    |       |--SEMI -> ; [249:17]
+    |       |--EXPR -> EXPR [250:13]
+    |       |   `--BOR_ASSIGN -> |= [250:13]
+    |       |       |--IDENT -> vint [250:8]
+    |       |       `--NUM_INT -> 1 [250:16]
+    |       |--SEMI -> ; [250:17]
+    |       |--EXPR -> EXPR [251:13]
+    |       |   `--BXOR_ASSIGN -> ^= [251:13]
+    |       |       |--IDENT -> vint [251:8]
+    |       |       `--NUM_INT -> 1 [251:16]
+    |       |--SEMI -> ; [251:17]
+    |       |--EXPR -> EXPR [252:13]
+    |       |   `--SL_ASSIGN -> <<= [252:13]
+    |       |       |--IDENT -> vint [252:8]
+    |       |       `--NUM_INT -> 1 [252:17]
+    |       |--SEMI -> ; [252:18]
+    |       |--EXPR -> EXPR [253:13]
+    |       |   `--SR_ASSIGN -> >>= [253:13]
+    |       |       |--IDENT -> vint [253:8]
+    |       |       `--NUM_INT -> 1 [253:17]
+    |       |--SEMI -> ; [253:18]
+    |       |--EXPR -> EXPR [254:13]
+    |       |   `--BSR_ASSIGN -> >>>= [254:13]
+    |       |       |--IDENT -> vint [254:8]
+    |       |       `--NUM_INT -> 1 [254:18]
+    |       |--SEMI -> ; [254:19]
+    |       |--EXPR -> EXPR [255:12]
+    |       |   `--POST_INC -> ++ [255:12]
+    |       |       `--IDENT -> vint [255:8]
+    |       |--SEMI -> ; [255:14]
+    |       |--EXPR -> EXPR [256:12]
+    |       |   `--POST_DEC -> -- [256:12]
+    |       |       `--IDENT -> vint [256:8]
+    |       |--SEMI -> ; [256:14]
+    |       |--EXPR -> EXPR [257:8]
+    |       |   `--INC -> ++ [257:8]
+    |       |       `--IDENT -> vint [257:10]
+    |       |--SEMI -> ; [257:14]
+    |       |--EXPR -> EXPR [258:8]
+    |       |   `--DEC -> -- [258:8]
+    |       |       `--IDENT -> vint [258:10]
+    |       |--SEMI -> ; [258:14]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [259:8]
+    |       |   |--MODIFIERS -> MODIFIERS [259:8]
+    |       |   |--TYPE -> TYPE [259:8]
+    |       |   |   |--IDENT -> String [259:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [259:14]
+    |       |   |       `--RBRACK -> ] [259:15]
+    |       |   |--IDENT -> arrayinit [259:17]
+    |       |   `--ASSIGN -> = [259:27]
+    |       |       `--ARRAY_INIT -> { [259:29]
+    |       |           `--RCURLY -> } [259:30]
+    |       |--SEMI -> ; [259:31]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [260:8]
+    |       |   |--MODIFIERS -> MODIFIERS [260:8]
+    |       |   |--TYPE -> TYPE [260:8]
+    |       |   |   |--IDENT -> String [260:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [260:14]
+    |       |   |       `--RBRACK -> ] [260:15]
+    |       |   |--IDENT -> arrayinit2 [260:17]
+    |       |   `--ASSIGN -> = [260:28]
+    |       |       `--ARRAY_INIT -> { [260:30]
+    |       |           |--EXPR -> EXPR [260:31]
+    |       |           |   `--STRING_LITERAL -> "" [260:31]
+    |       |           `--RCURLY -> } [260:33]
+    |       |--SEMI -> ; [260:34]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [261:8]
+    |       |   |--MODIFIERS -> MODIFIERS [261:8]
+    |       |   |--TYPE -> TYPE [261:8]
+    |       |   |   |--IDENT -> String [261:8]
+    |       |   |   `--ARRAY_DECLARATOR -> [ [261:14]
+    |       |   |       `--RBRACK -> ] [261:15]
+    |       |   |--IDENT -> arrayinit3 [261:17]
+    |       |   `--ASSIGN -> = [261:28]
+    |       |       `--ARRAY_INIT -> { [261:30]
+    |       |           |--EXPR -> EXPR [261:31]
+    |       |           |   `--STRING_LITERAL -> "" [261:31]
+    |       |           |--COMMA -> , [261:33]
+    |       |           |--EXPR -> EXPR [261:35]
+    |       |           |   `--STRING_LITERAL -> "" [261:35]
+    |       |           |--COMMA -> , [261:37]
+    |       |           `--RCURLY -> } [261:38]
+    |       |--SEMI -> ; [261:39]
+    |       |--EXPR -> EXPR [264:15]
+    |       |   `--ASSIGN -> = [264:15]
+    |       |       |--IDENT -> varray [264:8]
+    |       |       `--LITERAL_NEW -> new [264:17]
+    |       |           |--LITERAL_INT -> int [264:21]
+    |       |           |--ARRAY_DECLARATOR -> [ [264:24]
+    |       |           |   `--RBRACK -> ] [264:25]
+    |       |           `--ARRAY_INIT -> { [264:26]
+    |       |               `--RCURLY -> } [264:27]
+    |       |--SEMI -> ; [264:28]
+    |       |--EXPR -> EXPR [265:15]
+    |       |   `--ASSIGN -> = [265:15]
+    |       |       |--IDENT -> varray [265:8]
+    |       |       `--LITERAL_NEW -> new [265:17]
+    |       |           |--LITERAL_INT -> int [265:21]
+    |       |           |--ARRAY_DECLARATOR -> [ [265:24]
+    |       |           |   `--RBRACK -> ] [265:25]
+    |       |           `--ARRAY_INIT -> { [265:26]
+    |       |               |--EXPR -> EXPR [265:27]
+    |       |               |   `--NUM_INT -> 0 [265:27]
+    |       |               `--RCURLY -> } [265:28]
+    |       |--SEMI -> ; [265:29]
+    |       |--EXPR -> EXPR [266:15]
+    |       |   `--ASSIGN -> = [266:15]
+    |       |       |--IDENT -> varray [266:8]
+    |       |       `--LITERAL_NEW -> new [266:17]
+    |       |           |--LITERAL_INT -> int [266:21]
+    |       |           |--ARRAY_DECLARATOR -> [ [266:24]
+    |       |           |   `--RBRACK -> ] [266:25]
+    |       |           `--ARRAY_INIT -> { [266:26]
+    |       |               |--EXPR -> EXPR [266:27]
+    |       |               |   `--NUM_INT -> 0 [266:27]
+    |       |               |--COMMA -> , [266:28]
+    |       |               |--EXPR -> EXPR [266:30]
+    |       |               |   `--NUM_INT -> 1 [266:30]
+    |       |               `--RCURLY -> } [266:31]
+    |       |--SEMI -> ; [266:32]
+    |       |--EXPR -> EXPR [267:15]
+    |       |   `--ASSIGN -> = [267:15]
+    |       |       |--IDENT -> varray [267:8]
+    |       |       `--LITERAL_NEW -> new [267:17]
+    |       |           |--LITERAL_INT -> int [267:21]
+    |       |           `--ARRAY_DECLARATOR -> [ [267:24]
+    |       |               |--EXPR -> EXPR [267:25]
+    |       |               |   `--NUM_INT -> 5 [267:25]
+    |       |               `--RBRACK -> ] [267:26]
+    |       |--SEMI -> ; [267:27]
+    |       |--EXPR -> EXPR [268:14]
+    |       |   `--ASSIGN -> = [268:14]
+    |       |       |--IDENT -> vlist [268:8]
+    |       |       `--LITERAL_NEW -> new [268:16]
+    |       |           |--IDENT -> ArrayList [268:20]
+    |       |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [268:29]
+    |       |           |   |--GENERIC_START -> < [268:29]
+    |       |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [268:30]
+    |       |           |   |   `--IDENT -> String [268:30]
+    |       |           |   `--GENERIC_END -> > [268:36]
+    |       |           |--LPAREN -> ( [268:37]
+    |       |           |--ELIST -> ELIST [268:38]
+    |       |           `--RPAREN -> ) [268:38]
+    |       |--SEMI -> ; [268:39]
+    |       |--EXPR -> EXPR [269:13]
+    |       |   `--ASSIGN -> = [269:13]
+    |       |       |--IDENT -> vmap [269:8]
+    |       |       `--LITERAL_NEW -> new [269:15]
+    |       |           |--IDENT -> HashMap [269:19]
+    |       |           |--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [269:26]
+    |       |           |   |--GENERIC_START -> < [269:26]
+    |       |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [269:27]
+    |       |           |   |   `--IDENT -> String [269:27]
+    |       |           |   |--COMMA -> , [269:33]
+    |       |           |   |--TYPE_ARGUMENT -> TYPE_ARGUMENT [269:35]
+    |       |           |   |   |--IDENT -> String [269:35]
+    |       |           |   |   `--ARRAY_DECLARATOR -> [ [269:41]
+    |       |           |   |       `--RBRACK -> ] [269:42]
+    |       |           |   `--GENERIC_END -> > [269:43]
+    |       |           |--LPAREN -> ( [269:44]
+    |       |           |--ELIST -> ELIST [269:45]
+    |       |           `--RPAREN -> ) [269:45]
+    |       |--SEMI -> ; [269:46]
+    |       |--VARIABLE_DEF -> VARIABLE_DEF [270:8]
+    |       |   |--MODIFIERS -> MODIFIERS [270:8]
+    |       |   |--TYPE -> TYPE [270:8]
+    |       |   |   `--IDENT -> Object [270:8]
+    |       |   |--IDENT -> anonymous [270:15]
+    |       |   `--ASSIGN -> = [270:25]
+    |       |       `--EXPR -> EXPR [270:27]
+    |       |           `--LITERAL_NEW -> new [270:27]
+    |       |               |--IDENT -> InputRegressionJavaClass1 [270:31]
+    |       |               |--LPAREN -> ( [270:56]
+    |       |               |--ELIST -> ELIST [270:57]
+    |       |               |--RPAREN -> ) [270:57]
+    |       |               `--OBJBLOCK -> OBJBLOCK [270:59]
+    |       |                   |--LCURLY -> { [270:59]
+    |       |                   `--RCURLY -> } [270:60]
+    |       |--SEMI -> ; [270:61]
+    |       |--EMPTY_STAT -> ; [273:8]
+    |       |--EXPR -> EXPR [274:16]
+    |       |   `--ASSIGN -> = [274:16]
+    |       |       |--DOT -> . [274:12]
+    |       |       |   |--LITERAL_THIS -> this [274:8]
+    |       |       |   `--IDENT -> f1 [274:13]
+    |       |       `--NUM_INT -> 0 [274:18]
+    |       |--SEMI -> ; [274:19]
+    |       |--LABELED_STAT -> : [277:19]
+    |       |   |--IDENT -> test_label1 [277:8]
+    |       |   `--SLIST -> { [280:8]
+    |       |       `--RCURLY -> } [280:9]
+    |       |--LITERAL_IF -> if [281:8]
+    |       |   |--LPAREN -> ( [281:11]
+    |       |   |--EXPR -> EXPR [281:12]
+    |       |   |   `--LITERAL_TRUE -> true [281:12]
+    |       |   |--RPAREN -> ) [281:16]
+    |       |   `--EMPTY_STAT -> ; [281:18]
+    |       |--LITERAL_IF -> if [282:8]
+    |       |   |--LPAREN -> ( [282:11]
+    |       |   |--EXPR -> EXPR [282:12]
+    |       |   |   `--LITERAL_TRUE -> true [282:12]
+    |       |   |--RPAREN -> ) [282:16]
+    |       |   `--SLIST -> { [282:18]
+    |       |       `--RCURLY -> } [282:19]
+    |       |--LITERAL_IF -> if [283:8]
+    |       |   |--LPAREN -> ( [283:11]
+    |       |   |--EXPR -> EXPR [283:12]
+    |       |   |   `--LITERAL_TRUE -> true [283:12]
+    |       |   |--RPAREN -> ) [283:16]
+    |       |   |--SLIST -> { [283:18]
+    |       |   |   `--RCURLY -> } [283:19]
+    |       |   `--LITERAL_ELSE -> else [283:21]
+    |       |       `--EMPTY_STAT -> ; [283:26]
+    |       |--LITERAL_IF -> if [284:8]
+    |       |   |--LPAREN -> ( [284:11]
+    |       |   |--EXPR -> EXPR [284:12]
+    |       |   |   `--LITERAL_TRUE -> true [284:12]
+    |       |   |--RPAREN -> ) [284:16]
+    |       |   |--SLIST -> { [284:18]
+    |       |   |   `--RCURLY -> } [284:19]
+    |       |   `--LITERAL_ELSE -> else [284:21]
+    |       |       `--SLIST -> { [284:26]
+    |       |           `--RCURLY -> } [284:27]
+    |       |--LITERAL_IF -> if [285:8]
+    |       |   |--LPAREN -> ( [285:11]
+    |       |   |--EXPR -> EXPR [285:12]
+    |       |   |   `--IDENT -> b [285:12]
+    |       |   |--RPAREN -> ) [285:13]
+    |       |   `--SLIST -> { [285:15]
+    |       |       |--LITERAL_FOR -> for [285:17]
+    |       |       |   |--LPAREN -> ( [285:21]
+    |       |       |   |--FOR_INIT -> FOR_INIT [285:22]
+    |       |       |   |--SEMI -> ; [285:22]
+    |       |       |   |--FOR_CONDITION -> FOR_CONDITION [285:23]
+    |       |       |   |--SEMI -> ; [285:23]
+    |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [285:24]
+    |       |       |   |--RPAREN -> ) [285:24]
+    |       |       |   `--EMPTY_STAT -> ; [285:26]
+    |       |       `--RCURLY -> } [285:28]
+    |       |--LITERAL_IF -> if [286:8]
+    |       |   |--LPAREN -> ( [286:11]
+    |       |   |--EXPR -> EXPR [286:12]
+    |       |   |   `--IDENT -> b [286:12]
+    |       |   |--RPAREN -> ) [286:13]
+    |       |   `--SLIST -> { [286:15]
+    |       |       |--LITERAL_FOR -> for [286:17]
+    |       |       |   |--LPAREN -> ( [286:21]
+    |       |       |   |--FOR_INIT -> FOR_INIT [286:22]
+    |       |       |   |--SEMI -> ; [286:22]
+    |       |       |   |--FOR_CONDITION -> FOR_CONDITION [286:23]
+    |       |       |   |--SEMI -> ; [286:23]
+    |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [286:24]
+    |       |       |   |--RPAREN -> ) [286:24]
+    |       |       |   `--SLIST -> { [286:26]
+    |       |       |       `--RCURLY -> } [286:27]
+    |       |       `--RCURLY -> } [286:29]
+    |       |--LITERAL_FOR -> for [287:8]
+    |       |   |--LPAREN -> ( [287:12]
+    |       |   |--FOR_INIT -> FOR_INIT [287:13]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [287:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [287:13]
+    |       |   |       |--TYPE -> TYPE [287:13]
+    |       |   |       |   `--LITERAL_INT -> int [287:13]
+    |       |   |       |--IDENT -> i [287:17]
+    |       |   |       `--ASSIGN -> = [287:19]
+    |       |   |           `--EXPR -> EXPR [287:21]
+    |       |   |               `--NUM_INT -> 0 [287:21]
+    |       |   |--SEMI -> ; [287:22]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [287:26]
+    |       |   |   `--EXPR -> EXPR [287:26]
+    |       |   |       `--LT -> < [287:26]
+    |       |   |           |--IDENT -> i [287:24]
+    |       |   |           `--NUM_INT -> 1 [287:28]
+    |       |   |--SEMI -> ; [287:29]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [287:32]
+    |       |   |   `--ELIST -> ELIST [287:32]
+    |       |   |       `--EXPR -> EXPR [287:32]
+    |       |   |           `--POST_INC -> ++ [287:32]
+    |       |   |               `--IDENT -> i [287:31]
+    |       |   |--RPAREN -> ) [287:34]
+    |       |   `--SLIST -> { [287:36]
+    |       |       `--RCURLY -> } [287:37]
+    |       |--LITERAL_FOR -> for [288:8]
+    |       |   |--LPAREN -> ( [288:12]
+    |       |   |--FOR_INIT -> FOR_INIT [288:13]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [288:13]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [288:13]
+    |       |   |   |   |--TYPE -> TYPE [288:13]
+    |       |   |   |   |   `--LITERAL_INT -> int [288:13]
+    |       |   |   |   |--IDENT -> i [288:17]
+    |       |   |   |   `--ASSIGN -> = [288:19]
+    |       |   |   |       `--EXPR -> EXPR [288:21]
+    |       |   |   |           `--NUM_INT -> 0 [288:21]
+    |       |   |   |--COMMA -> , [288:22]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [288:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [288:13]
+    |       |   |       |--TYPE -> TYPE [288:13]
+    |       |   |       |   `--LITERAL_INT -> int [288:13]
+    |       |   |       |--IDENT -> j [288:24]
+    |       |   |       `--ASSIGN -> = [288:26]
+    |       |   |           `--EXPR -> EXPR [288:28]
+    |       |   |               `--NUM_INT -> 0 [288:28]
+    |       |   |--SEMI -> ; [288:29]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [288:33]
+    |       |   |   `--EXPR -> EXPR [288:33]
+    |       |   |       `--LT -> < [288:33]
+    |       |   |           |--IDENT -> i [288:31]
+    |       |   |           `--NUM_INT -> 1 [288:35]
+    |       |   |--SEMI -> ; [288:36]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [288:39]
+    |       |   |   `--ELIST -> ELIST [288:39]
+    |       |   |       |--EXPR -> EXPR [288:39]
+    |       |   |       |   `--POST_INC -> ++ [288:39]
+    |       |   |       |       `--IDENT -> i [288:38]
+    |       |   |       |--COMMA -> , [288:41]
+    |       |   |       `--EXPR -> EXPR [288:45]
+    |       |   |           `--PLUS_ASSIGN -> += [288:45]
+    |       |   |               |--IDENT -> j [288:43]
+    |       |   |               `--NUM_INT -> 2 [288:48]
+    |       |   |--RPAREN -> ) [288:49]
+    |       |   `--SLIST -> { [288:51]
+    |       |       `--RCURLY -> } [288:52]
+    |       |--LITERAL_FOR -> for [289:8]
+    |       |   |--LPAREN -> ( [289:12]
+    |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [289:13]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [289:13]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [289:13]
+    |       |   |   |   |--TYPE -> TYPE [289:13]
+    |       |   |   |   |   `--LITERAL_INT -> int [289:13]
+    |       |   |   |   `--IDENT -> value [289:17]
+    |       |   |   |--COLON -> : [289:22]
+    |       |   |   `--EXPR -> EXPR [289:24]
+    |       |   |       `--LITERAL_NEW -> new [289:24]
+    |       |   |           |--LITERAL_INT -> int [289:28]
+    |       |   |           |--ARRAY_DECLARATOR -> [ [289:31]
+    |       |   |           |   `--RBRACK -> ] [289:32]
+    |       |   |           `--ARRAY_INIT -> { [289:33]
+    |       |   |               `--RCURLY -> } [289:34]
+    |       |   |--RPAREN -> ) [289:35]
+    |       |   `--EMPTY_STAT -> ; [289:37]
+    |       |--LITERAL_FOR -> for [290:8]
+    |       |   |--LPAREN -> ( [290:12]
+    |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [290:13]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [290:13]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [290:13]
+    |       |   |   |   |--TYPE -> TYPE [290:13]
+    |       |   |   |   |   `--IDENT -> String [290:13]
+    |       |   |   |   `--IDENT -> s [290:20]
+    |       |   |   |--COLON -> : [290:22]
+    |       |   |   `--EXPR -> EXPR [290:24]
+    |       |   |       `--LITERAL_NEW -> new [290:24]
+    |       |   |           |--IDENT -> String [290:28]
+    |       |   |           |--ARRAY_DECLARATOR -> [ [290:34]
+    |       |   |           |   `--RBRACK -> ] [290:35]
+    |       |   |           `--ARRAY_INIT -> { [290:36]
+    |       |   |               `--RCURLY -> } [290:37]
+    |       |   |--RPAREN -> ) [290:38]
+    |       |   `--EMPTY_STAT -> ; [290:40]
+    |       |--LITERAL_FOR -> for [291:8]
+    |       |   |--LPAREN -> ( [291:12]
+    |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [291:13]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [291:13]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [291:13]
+    |       |   |   |   |   `--FINAL -> final [291:13]
+    |       |   |   |   |--TYPE -> TYPE [291:19]
+    |       |   |   |   |   `--IDENT -> String [291:19]
+    |       |   |   |   `--IDENT -> s [291:26]
+    |       |   |   |--COLON -> : [291:28]
+    |       |   |   `--EXPR -> EXPR [291:30]
+    |       |   |       `--LITERAL_NEW -> new [291:30]
+    |       |   |           |--IDENT -> String [291:34]
+    |       |   |           |--ARRAY_DECLARATOR -> [ [291:40]
+    |       |   |           |   `--RBRACK -> ] [291:41]
+    |       |   |           `--ARRAY_INIT -> { [291:42]
+    |       |   |               `--RCURLY -> } [291:43]
+    |       |   |--RPAREN -> ) [291:44]
+    |       |   `--EMPTY_STAT -> ; [291:46]
+    |       |--LITERAL_IF -> if [292:8]
+    |       |   |--LPAREN -> ( [292:11]
+    |       |   |--EXPR -> EXPR [292:12]
+    |       |   |   `--IDENT -> b [292:12]
+    |       |   |--RPAREN -> ) [292:13]
+    |       |   `--SLIST -> { [292:15]
+    |       |       |--LITERAL_WHILE -> while [292:17]
+    |       |       |   |--LPAREN -> ( [292:23]
+    |       |       |   |--EXPR -> EXPR [292:24]
+    |       |       |   |   `--LITERAL_TRUE -> true [292:24]
+    |       |       |   |--RPAREN -> ) [292:28]
+    |       |       |   `--EMPTY_STAT -> ; [292:30]
+    |       |       `--RCURLY -> } [292:32]
+    |       |--LITERAL_IF -> if [293:8]
+    |       |   |--LPAREN -> ( [293:11]
+    |       |   |--EXPR -> EXPR [293:12]
+    |       |   |   `--IDENT -> b [293:12]
+    |       |   |--RPAREN -> ) [293:13]
+    |       |   `--SLIST -> { [293:15]
+    |       |       |--LITERAL_WHILE -> while [293:17]
+    |       |       |   |--LPAREN -> ( [293:23]
+    |       |       |   |--EXPR -> EXPR [293:24]
+    |       |       |   |   `--LITERAL_TRUE -> true [293:24]
+    |       |       |   |--RPAREN -> ) [293:28]
+    |       |       |   `--SLIST -> { [293:30]
+    |       |       |       `--RCURLY -> } [293:31]
+    |       |       `--RCURLY -> } [293:33]
+    |       |--LITERAL_DO -> do [294:8]
+    |       |   |--SLIST -> { [294:11]
+    |       |   |   `--RCURLY -> } [294:12]
+    |       |   |--DO_WHILE -> while [294:14]
+    |       |   |--LPAREN -> ( [294:20]
+    |       |   |--EXPR -> EXPR [294:21]
+    |       |   |   `--LITERAL_FALSE -> false [294:21]
+    |       |   |--RPAREN -> ) [294:26]
+    |       |   `--SEMI -> ; [294:27]
+    |       |--LITERAL_SYNCHRONIZED -> synchronized [295:8]
+    |       |   |--LPAREN -> ( [295:21]
+    |       |   |--EXPR -> EXPR [295:22]
+    |       |   |   `--IDENT -> f9 [295:22]
+    |       |   |--RPAREN -> ) [295:24]
+    |       |   `--SLIST -> { [295:26]
+    |       |       `--RCURLY -> } [295:27]
+    |       |--LITERAL_SWITCH -> switch [297:8]
+    |       |   |--LPAREN -> ( [297:15]
+    |       |   |--EXPR -> EXPR [297:16]
+    |       |   |   `--NUM_INT -> 0 [297:16]
+    |       |   |--RPAREN -> ) [297:17]
+    |       |   |--LCURLY -> { [297:19]
+    |       |   |--CASE_GROUP -> CASE_GROUP [298:12]
+    |       |   |   |--LITERAL_CASE -> case [298:12]
+    |       |   |   |   |--EXPR -> EXPR [298:17]
+    |       |   |   |   |   `--NUM_INT -> 1 [298:17]
+    |       |   |   |   `--COLON -> : [298:18]
+    |       |   |   |--LITERAL_CASE -> case [299:12]
+    |       |   |   |   |--EXPR -> EXPR [299:17]
+    |       |   |   |   |   `--NUM_INT -> 0 [299:17]
+    |       |   |   |   `--COLON -> : [299:18]
+    |       |   |   `--SLIST -> SLIST [299:20]
+    |       |   |       `--LITERAL_BREAK -> break [299:20]
+    |       |   |           `--SEMI -> ; [299:25]
+    |       |   |--CASE_GROUP -> CASE_GROUP [300:12]
+    |       |   |   |--LITERAL_DEFAULT -> default [300:12]
+    |       |   |   |   `--COLON -> : [300:19]
+    |       |   |   `--SLIST -> SLIST [300:21]
+    |       |   |       `--LITERAL_BREAK -> break [300:21]
+    |       |   |           `--SEMI -> ; [300:26]
+    |       |   `--RCURLY -> } [301:8]
+    |       |--LITERAL_TRY -> try [303:8]
+    |       |   |--SLIST -> { [303:12]
+    |       |   |   |--LITERAL_IF -> if [304:12]
+    |       |   |   |   |--LPAREN -> ( [304:15]
+    |       |   |   |   |--EXPR -> EXPR [304:16]
+    |       |   |   |   |   `--IDENT -> b [304:16]
+    |       |   |   |   |--RPAREN -> ) [304:17]
+    |       |   |   |   `--SLIST -> { [304:19]
+    |       |   |   |       |--LITERAL_THROW -> throw [304:21]
+    |       |   |   |       |   |--EXPR -> EXPR [304:27]
+    |       |   |   |       |   |   `--LITERAL_NEW -> new [304:27]
+    |       |   |   |       |   |       |--IDENT -> IOException [304:31]
+    |       |   |   |       |   |       |--LPAREN -> ( [304:42]
+    |       |   |   |       |   |       |--ELIST -> ELIST [304:43]
+    |       |   |   |       |   |       `--RPAREN -> ) [304:43]
+    |       |   |   |       |   `--SEMI -> ; [304:44]
+    |       |   |   |       `--RCURLY -> } [304:46]
+    |       |   |   |--LITERAL_IF -> if [305:12]
+    |       |   |   |   |--LPAREN -> ( [305:15]
+    |       |   |   |   |--EXPR -> EXPR [305:16]
+    |       |   |   |   |   `--IDENT -> b [305:16]
+    |       |   |   |   |--RPAREN -> ) [305:17]
+    |       |   |   |   `--SLIST -> { [305:19]
+    |       |   |   |       |--LITERAL_THROW -> throw [305:21]
+    |       |   |   |       |   |--EXPR -> EXPR [305:27]
+    |       |   |   |       |   |   `--LITERAL_NEW -> new [305:27]
+    |       |   |   |       |   |       |--IDENT -> ArrayIndexOutOfBoundsException [305:31]
+    |       |   |   |       |   |       |--LPAREN -> ( [305:61]
+    |       |   |   |       |   |       |--ELIST -> ELIST [305:62]
+    |       |   |   |       |   |       `--RPAREN -> ) [305:62]
+    |       |   |   |       |   `--SEMI -> ; [305:63]
+    |       |   |   |       `--RCURLY -> } [305:65]
+    |       |   |   |--LITERAL_THROW -> throw [306:12]
+    |       |   |   |   |--EXPR -> EXPR [306:18]
+    |       |   |   |   |   `--LITERAL_NEW -> new [306:18]
+    |       |   |   |   |       |--IDENT -> Exception [306:22]
+    |       |   |   |   |       |--LPAREN -> ( [306:31]
+    |       |   |   |   |       |--ELIST -> ELIST [306:32]
+    |       |   |   |   |       `--RPAREN -> ) [306:32]
+    |       |   |   |   `--SEMI -> ; [306:33]
+    |       |   |   `--RCURLY -> } [307:8]
+    |       |   |--LITERAL_CATCH -> catch [307:10]
+    |       |   |   |--LPAREN -> ( [307:16]
+    |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [307:17]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [307:17]
+    |       |   |   |   |--TYPE -> TYPE [307:17]
+    |       |   |   |   |   |--IDENT -> IOException [307:17]
+    |       |   |   |   |   |--BOR -> | [307:29]
+    |       |   |   |   |   `--IDENT -> ArrayIndexOutOfBoundsException [307:31]
+    |       |   |   |   `--IDENT -> e [307:62]
+    |       |   |   |--RPAREN -> ) [307:63]
+    |       |   |   `--SLIST -> { [307:65]
+    |       |   |       `--RCURLY -> } [308:8]
+    |       |   |--LITERAL_CATCH -> catch [308:10]
+    |       |   |   |--LPAREN -> ( [308:16]
+    |       |   |   |--PARAMETER_DEF -> PARAMETER_DEF [308:17]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [308:17]
+    |       |   |   |   |--TYPE -> TYPE [308:17]
+    |       |   |   |   |   `--IDENT -> Exception [308:17]
+    |       |   |   |   `--IDENT -> e [308:27]
+    |       |   |   |--RPAREN -> ) [308:28]
+    |       |   |   `--SLIST -> { [308:30]
+    |       |   |       `--RCURLY -> } [309:8]
+    |       |   `--LITERAL_FINALLY -> finally [309:10]
+    |       |       `--SLIST -> { [309:18]
+    |       |           `--RCURLY -> } [309:19]
+    |       |--LITERAL_TRY -> try [310:8]
+    |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [310:12]
+    |       |   |   |--LPAREN -> ( [310:12]
+    |       |   |   |--RESOURCES -> RESOURCES [310:13]
+    |       |   |   |   `--RESOURCE -> RESOURCE [310:13]
+    |       |   |   |       |--MODIFIERS -> MODIFIERS [310:13]
+    |       |   |   |       |--TYPE -> TYPE [310:13]
+    |       |   |   |       |   `--IDENT -> BufferedReader [310:13]
+    |       |   |   |       |--IDENT -> br [310:28]
+    |       |   |   |       `--ASSIGN -> = [310:31]
+    |       |   |   |           `--EXPR -> EXPR [310:33]
+    |       |   |   |               `--LITERAL_NEW -> new [310:33]
+    |       |   |   |                   |--IDENT -> BufferedReader [310:37]
+    |       |   |   |                   |--LPAREN -> ( [310:51]
+    |       |   |   |                   |--ELIST -> ELIST [310:52]
+    |       |   |   |                   |   `--EXPR -> EXPR [310:52]
+    |       |   |   |                   |       `--LITERAL_NEW -> new [310:52]
+    |       |   |   |                   |           |--IDENT -> InputStreamReader [310:56]
+    |       |   |   |                   |           |--LPAREN -> ( [310:73]
+    |       |   |   |                   |           |--ELIST -> ELIST [310:74]
+    |       |   |   |                   |           |   |--EXPR -> EXPR [310:74]
+    |       |   |   |                   |           |   |   `--LITERAL_NULL -> null [310:74]
+    |       |   |   |                   |           |   |--COMMA -> , [310:78]
+    |       |   |   |                   |           |   `--EXPR -> EXPR [310:80]
+    |       |   |   |                   |           |       `--STRING_LITERAL -> "utf-8" [310:80]
+    |       |   |   |                   |           `--RPAREN -> ) [310:87]
+    |       |   |   |                   `--RPAREN -> ) [310:88]
+    |       |   |   `--RPAREN -> ) [310:89]
+    |       |   `--SLIST -> { [310:91]
+    |       |       `--RCURLY -> } [310:92]
+    |       |--LITERAL_TRY -> try [311:8]
+    |       |   |--RESOURCE_SPECIFICATION -> RESOURCE_SPECIFICATION [311:12]
+    |       |   |   |--LPAREN -> ( [311:12]
+    |       |   |   |--RESOURCES -> RESOURCES [311:13]
+    |       |   |   |   |--RESOURCE -> RESOURCE [311:13]
+    |       |   |   |   |   |--MODIFIERS -> MODIFIERS [311:13]
+    |       |   |   |   |   |--TYPE -> TYPE [311:13]
+    |       |   |   |   |   |   `--IDENT -> BufferedReader [311:13]
+    |       |   |   |   |   |--IDENT -> br1 [311:28]
+    |       |   |   |   |   `--ASSIGN -> = [311:32]
+    |       |   |   |   |       `--EXPR -> EXPR [311:34]
+    |       |   |   |   |           `--LITERAL_NEW -> new [311:34]
+    |       |   |   |   |               |--IDENT -> BufferedReader [311:38]
+    |       |   |   |   |               |--LPAREN -> ( [311:52]
+    |       |   |   |   |               |--ELIST -> ELIST [311:53]
+    |       |   |   |   |               |   `--EXPR -> EXPR [311:53]
+    |       |   |   |   |               |       `--LITERAL_NEW -> new [311:53]
+    |       |   |   |   |               |           |--IDENT -> InputStreamReader [311:57]
+    |       |   |   |   |               |           |--LPAREN -> ( [311:74]
+    |       |   |   |   |               |           |--ELIST -> ELIST [311:75]
+    |       |   |   |   |               |           |   |--EXPR -> EXPR [311:75]
+    |       |   |   |   |               |           |   |   `--LITERAL_NULL -> null [311:75]
+    |       |   |   |   |               |           |   |--COMMA -> , [311:79]
+    |       |   |   |   |               |           |   `--EXPR -> EXPR [311:81]
+    |       |   |   |   |               |           |       `--STRING_LITERAL -> "utf-8" [311:81]
+    |       |   |   |   |               |           `--RPAREN -> ) [311:88]
+    |       |   |   |   |               `--RPAREN -> ) [311:89]
+    |       |   |   |   |--SEMI -> ; [311:90]
+    |       |   |   |   `--RESOURCE -> RESOURCE [312:16]
+    |       |   |   |       |--MODIFIERS -> MODIFIERS [312:16]
+    |       |   |   |       |--TYPE -> TYPE [312:16]
+    |       |   |   |       |   `--IDENT -> BufferedReader [312:16]
+    |       |   |   |       |--IDENT -> br2 [312:31]
+    |       |   |   |       `--ASSIGN -> = [312:35]
+    |       |   |   |           `--EXPR -> EXPR [312:37]
+    |       |   |   |               `--LITERAL_NEW -> new [312:37]
+    |       |   |   |                   |--IDENT -> BufferedReader [312:41]
+    |       |   |   |                   |--LPAREN -> ( [312:55]
+    |       |   |   |                   |--ELIST -> ELIST [312:56]
+    |       |   |   |                   |   `--EXPR -> EXPR [312:56]
+    |       |   |   |                   |       `--LITERAL_NEW -> new [312:56]
+    |       |   |   |                   |           |--IDENT -> InputStreamReader [312:60]
+    |       |   |   |                   |           |--LPAREN -> ( [312:77]
+    |       |   |   |                   |           |--ELIST -> ELIST [312:78]
+    |       |   |   |                   |           |   |--EXPR -> EXPR [312:78]
+    |       |   |   |                   |           |   |   `--LITERAL_NULL -> null [312:78]
+    |       |   |   |                   |           |   |--COMMA -> , [312:82]
+    |       |   |   |                   |           |   `--EXPR -> EXPR [312:84]
+    |       |   |   |                   |           |       `--STRING_LITERAL -> "utf-8" [312:84]
+    |       |   |   |                   |           `--RPAREN -> ) [312:91]
+    |       |   |   |                   `--RPAREN -> ) [312:92]
+    |       |   |   |--SEMI -> ; [312:93]
+    |       |   |   `--RPAREN -> ) [312:94]
+    |       |   `--SLIST -> { [312:96]
+    |       |       `--RCURLY -> } [312:97]
+    |       |--EXPR -> EXPR [315:14]
+    |       |   `--ASSIGN -> = [315:14]
+    |       |       |--IDENT -> test4 [315:8]
+    |       |       `--DOT -> . [315:41]
+    |       |           |--IDENT -> InputRegressionJavaClass1 [315:16]
+    |       |           `--LITERAL_CLASS -> class [315:42]
+    |       |--SEMI -> ; [315:47]
+    |       |--EXPR -> EXPR [316:14]
+    |       |   `--ASSIGN -> = [316:14]
+    |       |       |--IDENT -> test4 [316:8]
+    |       |       `--DOT -> . [316:22]
+    |       |           |--IDENT -> List [316:16]
+    |       |           |--ARRAY_DECLARATOR -> [ [316:20]
+    |       |           |   `--RBRACK -> ] [316:21]
+    |       |           `--LITERAL_CLASS -> class [316:23]
+    |       |--SEMI -> ; [316:28]
+    |       |--EXPR -> EXPR [317:14]
+    |       |   `--ASSIGN -> = [317:14]
+    |       |       |--IDENT -> test4 [317:8]
+    |       |       `--DOT -> . [317:25]
+    |       |           |--LITERAL_BOOLEAN -> boolean [317:16]
+    |       |           |--ARRAY_DECLARATOR -> [ [317:23]
+    |       |           |   `--RBRACK -> ] [317:24]
+    |       |           `--LITERAL_CLASS -> class [317:26]
+    |       |--SEMI -> ; [317:31]
+    |       |--EXPR -> EXPR [318:18]
+    |       |   `--ASSIGN -> = [318:18]
+    |       |       |--INDEX_OP -> [ [318:14]
+    |       |       |   |--IDENT -> varray [318:8]
+    |       |       |   |--EXPR -> EXPR [318:15]
+    |       |       |   |   `--NUM_INT -> 0 [318:15]
+    |       |       |   `--RBRACK -> ] [318:16]
+    |       |       `--NUM_INT -> 0 [318:20]
+    |       |--SEMI -> ; [318:21]
+    |       |--LITERAL_FOR -> for [319:8]
+    |       |   |--LPAREN -> ( [319:12]
+    |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [319:13]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [319:13]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [319:13]
+    |       |   |   |   |--TYPE -> TYPE [319:13]
+    |       |   |   |   |   |--IDENT -> String [319:13]
+    |       |   |   |   |   `--ARRAY_DECLARATOR -> [ [319:19]
+    |       |   |   |   |       `--RBRACK -> ] [319:20]
+    |       |   |   |   `--IDENT -> s [319:22]
+    |       |   |   |--COLON -> : [319:24]
+    |       |   |   `--EXPR -> EXPR [319:26]
+    |       |   |       `--LITERAL_NEW -> new [319:26]
+    |       |   |           |--IDENT -> String [319:30]
+    |       |   |           |--ARRAY_DECLARATOR -> [ [319:36]
+    |       |   |           |   `--RBRACK -> ] [319:37]
+    |       |   |           |--ARRAY_DECLARATOR -> [ [319:38]
+    |       |   |           |   `--RBRACK -> ] [319:39]
+    |       |   |           `--ARRAY_INIT -> { [319:40]
+    |       |   |               |--ARRAY_INIT -> { [319:41]
+    |       |   |               |   `--RCURLY -> } [319:42]
+    |       |   |               `--RCURLY -> } [319:43]
+    |       |   |--RPAREN -> ) [319:44]
+    |       |   `--EMPTY_STAT -> ; [319:46]
+    |       |--LITERAL_FOR -> for [320:8]
+    |       |   |--LPAREN -> ( [320:12]
+    |       |   |--FOR_EACH_CLAUSE -> FOR_EACH_CLAUSE [320:16]
+    |       |   |   |--VARIABLE_DEF -> VARIABLE_DEF [320:16]
+    |       |   |   |   |--MODIFIERS -> MODIFIERS [320:16]
+    |       |   |   |   |--TYPE -> TYPE [320:16]
+    |       |   |   |   |   `--DOT -> . [320:16]
+    |       |   |   |   |       |--IDENT -> Map [320:13]
+    |       |   |   |   |       |--IDENT -> Entry [320:17]
+    |       |   |   |   |       `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS [320:22]
+    |       |   |   |   |           |--GENERIC_START -> < [320:22]
+    |       |   |   |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [320:23]
+    |       |   |   |   |           |   `--IDENT -> String [320:23]
+    |       |   |   |   |           |--COMMA -> , [320:29]
+    |       |   |   |   |           |--TYPE_ARGUMENT -> TYPE_ARGUMENT [320:31]
+    |       |   |   |   |           |   |--IDENT -> String [320:31]
+    |       |   |   |   |           |   `--ARRAY_DECLARATOR -> [ [320:37]
+    |       |   |   |   |           |       `--RBRACK -> ] [320:38]
+    |       |   |   |   |           `--GENERIC_END -> > [320:39]
+    |       |   |   |   `--IDENT -> e [320:41]
+    |       |   |   |--COLON -> : [320:43]
+    |       |   |   `--EXPR -> EXPR [320:58]
+    |       |   |       `--METHOD_CALL -> ( [320:58]
+    |       |   |           |--DOT -> . [320:49]
+    |       |   |           |   |--IDENT -> vmap [320:45]
+    |       |   |           |   `--IDENT -> entrySet [320:50]
+    |       |   |           |--ELIST -> ELIST [320:59]
+    |       |   |           `--RPAREN -> ) [320:59]
+    |       |   |--RPAREN -> ) [320:60]
+    |       |   `--SLIST -> { [320:62]
+    |       |       `--RCURLY -> } [320:64]
+    |       |--LITERAL_FOR -> for [323:8]
+    |       |   |--LPAREN -> ( [323:12]
+    |       |   |--FOR_INIT -> FOR_INIT [323:13]
+    |       |   |--SEMI -> ; [323:13]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [323:14]
+    |       |   |--SEMI -> ; [323:14]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [323:15]
+    |       |   |--RPAREN -> ) [323:15]
+    |       |   `--SLIST -> { [323:17]
+    |       |       |--LITERAL_BREAK -> break [323:18]
+    |       |       |   `--SEMI -> ; [323:23]
+    |       |       `--RCURLY -> } [323:24]
+    |       |--LABELED_STAT -> : [324:19]
+    |       |   |--IDENT -> test_label2 [324:8]
+    |       |   `--LITERAL_FOR -> for [325:8]
+    |       |       |--LPAREN -> ( [325:12]
+    |       |       |--FOR_INIT -> FOR_INIT [325:13]
+    |       |       |--SEMI -> ; [325:13]
+    |       |       |--FOR_CONDITION -> FOR_CONDITION [325:14]
+    |       |       |--SEMI -> ; [325:14]
+    |       |       |--FOR_ITERATOR -> FOR_ITERATOR [325:15]
+    |       |       |--RPAREN -> ) [325:15]
+    |       |       `--SLIST -> { [325:17]
+    |       |           |--LITERAL_BREAK -> break [325:18]
+    |       |           |   |--IDENT -> test_label2 [325:24]
+    |       |           |   `--SEMI -> ; [325:35]
+    |       |           `--RCURLY -> } [325:36]
+    |       |--LITERAL_IF -> if [326:8]
+    |       |   |--LPAREN -> ( [326:11]
+    |       |   |--EXPR -> EXPR [326:12]
+    |       |   |   `--IDENT -> b [326:12]
+    |       |   |--RPAREN -> ) [326:13]
+    |       |   `--SLIST -> { [326:15]
+    |       |       |--LITERAL_FOR -> for [326:17]
+    |       |       |   |--LPAREN -> ( [326:21]
+    |       |       |   |--FOR_INIT -> FOR_INIT [326:22]
+    |       |       |   |--SEMI -> ; [326:22]
+    |       |       |   |--FOR_CONDITION -> FOR_CONDITION [326:23]
+    |       |       |   |--SEMI -> ; [326:23]
+    |       |       |   |--FOR_ITERATOR -> FOR_ITERATOR [326:24]
+    |       |       |   |--RPAREN -> ) [326:24]
+    |       |       |   `--SLIST -> { [326:26]
+    |       |       |       |--LITERAL_CONTINUE -> continue [326:27]
+    |       |       |       |   `--SEMI -> ; [326:35]
+    |       |       |       `--RCURLY -> } [326:36]
+    |       |       `--RCURLY -> } [326:38]
+    |       |--LITERAL_IF -> if [327:8]
+    |       |   |--LPAREN -> ( [327:11]
+    |       |   |--EXPR -> EXPR [327:12]
+    |       |   |   `--IDENT -> b [327:12]
+    |       |   |--RPAREN -> ) [327:13]
+    |       |   `--SLIST -> { [327:15]
+    |       |       |--LABELED_STAT -> : [327:28]
+    |       |       |   |--IDENT -> test_label3 [327:17]
+    |       |       |   `--LITERAL_FOR -> for [327:30]
+    |       |       |       |--LPAREN -> ( [327:34]
+    |       |       |       |--FOR_INIT -> FOR_INIT [327:35]
+    |       |       |       |--SEMI -> ; [327:35]
+    |       |       |       |--FOR_CONDITION -> FOR_CONDITION [327:36]
+    |       |       |       |--SEMI -> ; [327:36]
+    |       |       |       |--FOR_ITERATOR -> FOR_ITERATOR [327:37]
+    |       |       |       |--RPAREN -> ) [327:37]
+    |       |       |       `--SLIST -> { [327:39]
+    |       |       |           |--LITERAL_CONTINUE -> continue [327:40]
+    |       |       |           |   |--IDENT -> test_label3 [327:49]
+    |       |       |           |   `--SEMI -> ; [327:60]
+    |       |       |           `--RCURLY -> } [327:61]
+    |       |       `--RCURLY -> } [327:63]
+    |       |--LITERAL_IF -> if [328:8]
+    |       |   |--LPAREN -> ( [328:11]
+    |       |   |--EXPR -> EXPR [328:12]
+    |       |   |   `--LITERAL_FALSE -> false [328:12]
+    |       |   |--RPAREN -> ) [328:17]
+    |       |   `--LITERAL_RETURN -> return [328:19]
+    |       |       `--SEMI -> ; [328:25]
+    |       |--LITERAL_IF -> if [329:8]
+    |       |   |--LPAREN -> ( [329:11]
+    |       |   |--EXPR -> EXPR [329:12]
+    |       |   |   `--LITERAL_FALSE -> false [329:12]
+    |       |   |--RPAREN -> ) [329:17]
+    |       |   `--LITERAL_THROW -> throw [329:19]
+    |       |       |--EXPR -> EXPR [329:25]
+    |       |       |   `--LITERAL_NEW -> new [329:25]
+    |       |       |       |--IDENT -> Exception [329:29]
+    |       |       |       |--LPAREN -> ( [329:38]
+    |       |       |       |--ELIST -> ELIST [329:39]
+    |       |       |       `--RPAREN -> ) [329:39]
+    |       |       `--SEMI -> ; [329:40]
+    |       |--LITERAL_ASSERT -> assert [330:8]
+    |       |   |--EXPR -> EXPR [330:14]
+    |       |   |   |--LPAREN -> ( [330:14]
+    |       |   |   |--LITERAL_FALSE -> false [330:15]
+    |       |   |   `--RPAREN -> ) [330:20]
+    |       |   `--SEMI -> ; [330:21]
+    |       |--LITERAL_ASSERT -> assert [331:8]
+    |       |   |--EXPR -> EXPR [331:15]
+    |       |   |   `--LITERAL_TRUE -> true [331:15]
+    |       |   |--COLON -> : [331:20]
+    |       |   |--EXPR -> EXPR [331:22]
+    |       |   |   `--STRING_LITERAL -> "false" [331:22]
+    |       |   `--SEMI -> ; [331:29]
+    |       |--EXPR -> EXPR [332:11]
+    |       |   `--ASSIGN -> = [332:11]
+    |       |       |--IDENT -> f9 [332:8]
+    |       |       `--TYPECAST -> ( [332:13]
+    |       |           |--TYPE -> TYPE [332:14]
+    |       |           |   `--IDENT -> Object [332:14]
+    |       |           |--RPAREN -> ) [332:20]
+    |       |           `--IDENT -> f9 [332:22]
+    |       |--SEMI -> ; [332:24]
+    |       |--EXPR -> EXPR [333:17]
+    |       |   `--METHOD_CALL -> ( [333:17]
+    |       |       |--DOT -> . [333:10]
+    |       |       |   |--IDENT -> f9 [333:8]
+    |       |       |   `--IDENT -> equals [333:11]
+    |       |       |--ELIST -> ELIST [333:18]
+    |       |       |   `--EXPR -> EXPR [333:18]
+    |       |       |       |--LPAREN -> ( [333:18]
+    |       |       |       |--LPAREN -> ( [333:19]
+    |       |       |       |--ASSIGN -> = [333:28]
+    |       |       |       |   |--IDENT -> vstring [333:20]
+    |       |       |       |   `--STRING_LITERAL -> "" [333:30]
+    |       |       |       |--RPAREN -> ) [333:32]
+    |       |       |       `--RPAREN -> ) [333:33]
+    |       |       `--RPAREN -> ) [333:34]
+    |       |--SEMI -> ; [333:35]
+    |       |--LITERAL_FOR -> for [334:8]
+    |       |   |--LPAREN -> ( [334:12]
+    |       |   |--FOR_INIT -> FOR_INIT [334:13]
+    |       |   |   `--VARIABLE_DEF -> VARIABLE_DEF [334:13]
+    |       |   |       |--MODIFIERS -> MODIFIERS [334:13]
+    |       |   |       |--TYPE -> TYPE [334:13]
+    |       |   |       |   `--LITERAL_INT -> int [334:13]
+    |       |   |       |--IDENT -> i [334:17]
+    |       |   |       `--ASSIGN -> = [334:19]
+    |       |   |           `--EXPR -> EXPR [334:21]
+    |       |   |               `--NUM_INT -> 0 [334:21]
+    |       |   |--SEMI -> ; [334:22]
+    |       |   |--FOR_CONDITION -> FOR_CONDITION [334:24]
+    |       |   |   `--EXPR -> EXPR [334:24]
+    |       |   |       |--LPAREN -> ( [334:24]
+    |       |   |       |--LT -> < [334:29]
+    |       |   |       |   |--LPAREN -> ( [334:25]
+    |       |   |       |   |--IDENT -> i [334:26]
+    |       |   |       |   |--RPAREN -> ) [334:27]
+    |       |   |       |   |--LPAREN -> ( [334:31]
+    |       |   |       |   |--PLUS -> + [334:33]
+    |       |   |       |   |   |--NUM_INT -> 6 [334:32]
+    |       |   |       |   |   `--NUM_INT -> 6 [334:34]
+    |       |   |       |   `--RPAREN -> ) [334:35]
+    |       |   |       `--RPAREN -> ) [334:36]
+    |       |   |--SEMI -> ; [334:37]
+    |       |   |--FOR_ITERATOR -> FOR_ITERATOR [334:40]
+    |       |   |   `--ELIST -> ELIST [334:40]
+    |       |   |       `--EXPR -> EXPR [334:40]
+    |       |   |           `--POST_INC -> ++ [334:40]
+    |       |   |               `--IDENT -> i [334:39]
+    |       |   |--RPAREN -> ) [334:42]
+    |       |   `--EMPTY_STAT -> ; [334:44]
+    |       |--LITERAL_IF -> if [335:8]
+    |       |   |--LPAREN -> ( [335:11]
+    |       |   |--EXPR -> EXPR [335:12]
+    |       |   |   |--LPAREN -> ( [335:12]
+    |       |   |   |--BAND -> & [335:15]
+    |       |   |   |   |--IDENT -> b [335:13]
+    |       |   |   |   `--IDENT -> b [335:17]
+    |       |   |   `--RPAREN -> ) [335:18]
+    |       |   |--RPAREN -> ) [335:19]
+    |       |   `--SLIST -> { [335:21]
+    |       |       `--RCURLY -> } [335:22]
+    |       |--EXPR -> EXPR [338:13]
+    |       |   `--ASSIGN -> = [338:13]
+    |       |       |--IDENT -> vint [338:8]
+    |       |       `--QUESTION -> ? [338:24]
+    |       |           |--IDENT -> vboolean [338:15]
+    |       |           |--LPAREN -> ( [338:26]
+    |       |           |--ASSIGN -> = [338:32]
+    |       |           |   |--IDENT -> vint [338:27]
+    |       |           |   `--NUM_INT -> 1 [338:34]
+    |       |           |--RPAREN -> ) [338:35]
+    |       |           |--COLON -> : [338:37]
+    |       |           |--LPAREN -> ( [338:39]
+    |       |           |--ASSIGN -> = [338:45]
+    |       |           |   |--IDENT -> vint [338:40]
+    |       |           |   `--NUM_INT -> 0 [338:47]
+    |       |           `--RPAREN -> ) [338:48]
+    |       |--SEMI -> ; [338:49]
+    |       |--EXPR -> EXPR [339:21]
+    |       |   `--ASSIGN -> = [339:21]
+    |       |       |--INDEX_OP -> [ [339:14]
+    |       |       |   |--IDENT -> varray [339:8]
+    |       |       |   |--EXPR -> EXPR [339:15]
+    |       |       |   |   `--IDENT -> vint [339:15]
+    |       |       |   `--RBRACK -> ] [339:19]
+    |       |       `--METHOD_CALL -> ( [339:39]
+    |       |           |--DOT -> . [339:30]
+    |       |           |   |--IDENT -> Integer [339:23]
+    |       |           |   `--IDENT -> parseInt [339:31]
+    |       |           |--ELIST -> ELIST [339:40]
+    |       |           |   `--EXPR -> EXPR [339:40]
+    |       |           |       `--STRING_LITERAL -> "0" [339:40]
+    |       |           `--RPAREN -> ) [339:43]
+    |       |--SEMI -> ; [339:44]
+    |       `--RCURLY -> } [340:4]
+    |--ANNOTATION_DEF -> ANNOTATION_DEF [342:4]
+    |   |--MODIFIERS -> MODIFIERS [342:4]
+    |   |   `--LITERAL_PUBLIC -> public [342:4]
+    |   |--AT -> @ [342:11]
+    |   |--LITERAL_INTERFACE -> interface [342:12]
+    |   |--IDENT -> innerAnnotation [342:22]
+    |   `--OBJBLOCK -> OBJBLOCK [342:38]
+    |       |--LCURLY -> { [342:38]
+    |       `--RCURLY -> } [342:39]
+    `--RCURLY -> } [343:0]
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/PackageAnnotations.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/PackageAnnotations.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/PackageAnnotations.java
@@ -0,0 +1,24 @@
+package com.puppycrawl.tools.checkstyle.grammar.antlr4;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.Target;
+
+/**
+ * This is not a test-input. Actual test input is in the file package-info.java.
+ */
+
+@Target(ElementType.PACKAGE)
+@interface PackageAnnotations {
+
+    PackageAnnotation[] value();
+
+}
+
+@Repeatable(PackageAnnotations.class)
+@Target(ElementType.PACKAGE)
+@interface PackageAnnotation  {
+
+    String value() default  "";
+
+}
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/package-info.java b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/package-info.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/grammar/antlr4/package-info.java
@@ -0,0 +1,11 @@
+@PackageAnnotation(value = "foo")
+  @PackageAnnotation("") //warn
+@PackageAnnotation(
+        "bar"
+)
+package
+        com.
+                puppycrawl.
+                tools
+                .checkstyle.grammar
+                .antlr4;
diff --git a/src/test/resources/com/puppycrawl/tools/checkstyle/javaparser/InputJavaParserNoStackOverflowOnDeepStringConcat.java b/src/test/resources/com/puppycrawl/tools/checkstyle/javaparser/InputJavaParserNoStackOverflowOnDeepStringConcat.java
new file mode 100644
--- /dev/null
+++ b/src/test/resources/com/puppycrawl/tools/checkstyle/javaparser/InputJavaParserNoStackOverflowOnDeepStringConcat.java
@@ -0,0 +1,275 @@
+package com.puppycrawl.tools.checkstyle.javaparser;
+
+public class InputJavaParserNoStackOverflowOnDeepStringConcat {
+    public static final String X =
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+"a"+
+
+        "b";
+}

Upgrade Java Grammar from ANTLR2 to ANTLR4
From https://github.com/checkstyle/checkstyle/wiki/Checkstyle-GSoC-2021-Project-Ideas#project-name-upgrade-java-grammar-from-antlr2-to-antlr4:

> Checkstyle needs to have new Java grammar that is based on ANTLR4 version. This task is very difficult but it is critical for Checkstyle as ANTLR2 library is not supported (from 2006) and is far less efficient. Old version has a bunch of syntax analysis limitations that have already been resolved in ANTLR4. Our team is already experiencing difficulties with support of current grammar as it is too complicated due to limited parsing abilities of ANTLR2.

In this issue, we can discuss finer points of this upgrade and remaining issues from https://github.com/checkstyle-antlr4/checkstyle-antlr4:

[Grammar should use all caps in naming of literals
](https://github.com/checkstyle-antlr4/checkstyle-antlr4/issues/22)

[Criteria for main repo merge](https://github.com/checkstyle-antlr4/checkstyle-antlr4/issues/13)

[Add EOF token to AST](https://github.com/checkstyle-antlr4/checkstyle-antlr4/issues/12)

There are a couple of cases where Checkstyle can currently parse non-compilable files:

[Example 1](https://github.com/INRIA/spoon/blob/master/src/test/resources/executable-reference/Foo.java)

reason for not compiling - missing semicolon on line 7.

[Example 2](https://github.com/INRIA/spoon/blob/spoon-core-8.0.0/src/test/resources/noclasspath/SubscriptionAdapter.java)

reason for not compiling - super constructor call not first statement in constructor (line 15)

There are a few good reasons to drop support for this syntax:

1. Performance - especially for example 2, supporting this syntax makes for more complicated and ambiguous grammar
2. Checkstyle shouldn't be expected to parse Java syntax that doesn't compile.


Is there any good reason to continue supporting this syntax?

No. If the java compiler cannot compile a file, there is no much reason to parse such file.
This is documented feature: https://checkstyle.org/writingchecks.html#Limitations