From 63f97f68f644b4e77aebe4b09d22995cf2412399 Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Sun, 22 May 2016 23:32:10 +0600
Subject: [PATCH 01/22] UPCSEC-3193 Created basic version of 'Dropping Java'
 grammar and its corresponding lexer and parser

---
 .gitignore                                    |   37 +-
 build.gradle                                  |    2 +
 .../testing/dropper/lang/DropletChecker.java  |   29 +
 .../dropper/lang/DropperTreeListener.java     |   35 +
 .../upc/testing/dropper/lang/DroppingJava.g4  | 1116 +++
 .../dropper/lang/gen/DroppingJava.tokens      |  205 +
 .../lang/gen/DroppingJavaBaseListener.java    | 1467 +++
 .../dropper/lang/gen/DroppingJavaLexer.java   |  583 ++
 .../dropper/lang/gen/DroppingJavaLexer.tokens |  205 +
 .../lang/gen/DroppingJavaListener.java        | 1212 +++
 .../dropper/lang/gen/DroppingJavaParser.java  | 8310 +++++++++++++++++
 11 files changed, 13200 insertions(+), 1 deletion(-)
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/DropletChecker.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJava.tokens
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.tokens
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java

diff --git a/.gitignore b/.gitignore
index 939e22d..babe21f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,6 +10,41 @@ gradle-app.setting
 !gradle-wrapper.jar
 
 # Cache of project
+### JetBrains template
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+## File-based project format:
+
+## Plugin-specific files:
+
+# IntelliJ
+
+# mpeltonen/sbt-idea plugin
+
+# JIRA plugin
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+### Java template
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.war
+*.ear
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+### Gradle template
+
+# Ignore Gradle GUI config
+
+# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
+
+# Cache of project
+
+# # Work around https://youtrack.jetbrains.com/issue/IDEA-116898
+# gradle/wrapper/gradle-wrapper.properties
 .gradletasknamecache
 
 # # Work around https://youtrack.jetbrains.com/issue/IDEA-116898
@@ -23,7 +58,7 @@ gradle-app.setting
 
 ## Project format:
 *.iws
-*.iml
+*.ipr
 
 ## Plugin-specific files:
 
diff --git a/build.gradle b/build.gradle
index d218e2f..68e5ecd 100644
--- a/build.gradle
+++ b/build.gradle
@@ -17,6 +17,8 @@ configurations {
 dependencies {
     provided 'org.javassist:javassist:3.20.0-GA'
     compile 'org.slf4j:slf4j-api:1.7.7'
+    // http://mvnrepository.com/artifact/org.antlr/antlr4-runtime
+    compile group: 'org.antlr', name: 'antlr4-runtime', version: '4.5.3'
     testCompile group: 'junit', name: 'junit', version: '4.11'
 }
 
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletChecker.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletChecker.java
new file mode 100644
index 0000000..f6118a7
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletChecker.java
@@ -0,0 +1,29 @@
+package ru.ftc.upc.testing.dropper.lang;
+
+import org.antlr.v4.runtime.ANTLRFileStream;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.TokenStream;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaLexer;
+import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
+
+import java.io.IOException;
+
+/**
+ * @author Toparvion
+ */
+public class DropletChecker {
+
+  public static void main(String[] args) throws IOException {
+    ANTLRFileStream fileStream = new ANTLRFileStream("C:\\lang\\dropper\\src\\main\\java\\ru\\ftc\\upc\\testing\\dropper\\PatchingTransformer.java");
+    DroppingJavaLexer lexer = new DroppingJavaLexer(fileStream);
+    TokenStream tokenStream = new CommonTokenStream(lexer);
+    DroppingJavaParser parser = new DroppingJavaParser(tokenStream);
+    ParseTree tree = parser.compilationUnit();
+
+    DropperTreeListener listener = new DropperTreeListener();
+    ParseTreeWalker walker = new ParseTreeWalker();
+    walker.walk(listener, tree);
+  }
+}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java
new file mode 100644
index 0000000..388de65
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java
@@ -0,0 +1,35 @@
+package ru.ftc.upc.testing.dropper.lang;
+
+import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaBaseListener;
+import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
+
+/**
+ * @author Toparvion
+ */
+public class DropperTreeListener extends DroppingJavaBaseListener {
+
+  @Override
+  public void enterVariableDeclaratorId(DroppingJavaParser.VariableDeclaratorIdContext ctx) {
+    System.out.println("Method formal parameter name found: " + ctx.getText());
+  }
+
+  @Override
+  public void enterClassName(DroppingJavaParser.ClassNameContext ctx) {
+    System.out.println("Class name found: " + ctx.Identifier().getText());
+  }
+
+  @Override
+  public void enterSingleTypeImportDeclaration(DroppingJavaParser.SingleTypeImportDeclarationContext ctx) {
+    System.out.printf("Single import found: %s\n", ctx.typeName().getText());
+  }
+
+  @Override
+  public void enterMethodName(DroppingJavaParser.MethodNameContext ctx) {
+    System.out.printf("Method name found: %s\n", ctx.Identifier().getText());
+  }
+
+  @Override
+  public void enterConstructorName(DroppingJavaParser.ConstructorNameContext ctx) {
+    System.out.printf("Constructor name found: %s\n", ctx.Identifier().getText());
+  }
+}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4 b/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4
new file mode 100644
index 0000000..92d8a8b
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4
@@ -0,0 +1,1116 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2014 Terence Parr
+ *  Copyright (c) 2014 Sam Harwell
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * A Java 8 grammar for ANTLR 4 derived from the Java Language Specification
+ * chapter 19.
+ *
+ * NOTE: This grammar results in a generated parser that is much slower
+ *       than the Java 7 grammar in the grammars-v4/java directory. This
+ *     one is, however, extremely close to the spec.
+ *
+ * You can test with
+ *
+ *  $ antlr4 Java8.g4
+ *  $ javac *.java
+ *  $ grun Java8 compilationUnit *.java
+ *
+ * Or,
+~/antlr/code/grammars-v4/java8 $ java Test .
+/Users/parrt/antlr/code/grammars-v4/java8/./Java8BaseListener.java
+/Users/parrt/antlr/code/grammars-v4/java8/./Java8Lexer.java
+/Users/parrt/antlr/code/grammars-v4/java8/./Java8Listener.java
+/Users/parrt/antlr/code/grammars-v4/java8/./Java8Parser.java
+/Users/parrt/antlr/code/grammars-v4/java8/./Test.java
+Total lexer+parser time 30844ms.
+ */
+grammar DroppingJava;
+
+/*
+ * Productions from §3 (Lexical Structure)
+ */
+
+/*
+ * Productions from §4 (Types, Values, and Variables)
+ */
+
+primitiveType
+	:	annotation* numericType
+	|	annotation* 'boolean'
+	;
+
+numericType
+	:	integralType
+	|	floatingPointType
+	;
+
+integralType
+	:	'byte'
+	|	'short'
+	|	'int'
+	|	'long'
+	|	'char'
+	;
+
+floatingPointType
+	:	'float'
+	|	'double'
+	;
+
+referenceType
+	:	classOrInterfaceType
+	|	typeVariable
+	|	arrayType
+	;
+
+classOrInterfaceType
+	:	(	classType_lfno_classOrInterfaceType
+		|	interfaceType_lfno_classOrInterfaceType
+		)
+		(	classType_lf_classOrInterfaceType
+		|	interfaceType_lf_classOrInterfaceType
+		)*
+	;
+
+classType
+	:	annotation* Identifier typeArguments?
+	|	classOrInterfaceType '.' annotation* Identifier typeArguments?
+	;
+
+classType_lf_classOrInterfaceType
+	:	'.' annotation* Identifier typeArguments?
+	;
+
+classType_lfno_classOrInterfaceType
+	:	annotation* Identifier typeArguments?
+	;
+
+interfaceType
+	:	classType
+	;
+
+interfaceType_lf_classOrInterfaceType
+	:	classType_lf_classOrInterfaceType
+	;
+
+interfaceType_lfno_classOrInterfaceType
+	:	classType_lfno_classOrInterfaceType
+	;
+
+typeVariable
+	:	annotation* Identifier
+	;
+
+arrayType
+	:	primitiveType dims
+	|	classOrInterfaceType dims
+	|	typeVariable dims
+	;
+
+dims
+	:	annotation* '[' ']' (annotation* '[' ']')*
+	;
+
+typeParameter
+	:	typeParameterModifier* Identifier typeBound?
+	;
+
+typeParameterModifier
+	:	annotation
+	;
+
+typeBound
+	:	'extends' typeVariable
+	|	'extends' classOrInterfaceType additionalBound*
+	;
+
+additionalBound
+	:	'&' interfaceType
+	;
+
+typeArguments
+	:	'<' typeArgumentList '>'
+	;
+
+typeArgumentList
+	:	typeArgument (',' typeArgument)*
+	;
+
+typeArgument
+	:	referenceType
+	|	wildcard
+	;
+
+wildcard
+	:	annotation* '?' wildcardBounds?
+	;
+
+wildcardBounds
+	:	'extends' referenceType
+	|	'super' referenceType
+	;
+
+/*
+ * Productions from §6 (Names)
+ */
+
+typeName
+	:	Identifier
+	|	packageOrTypeName '.' Identifier
+	;
+
+packageOrTypeName
+	:	Identifier
+	|	packageOrTypeName '.' Identifier
+	;
+
+expressionName
+	:	Identifier
+	|	ambiguousName '.' Identifier
+	;
+
+ambiguousName
+	:	Identifier
+	|	ambiguousName '.' Identifier
+	;
+
+/*
+ * Productions from §7 (Packages)
+ */
+
+compilationUnit
+	:	packageDeclaration? importDeclaration* typeDeclaration* EOF
+	;
+
+packageDeclaration
+	:	packageModifier* 'package' Identifier ('.' Identifier)* ';'
+	;
+
+packageModifier
+	:	annotation
+	;
+
+importDeclaration
+	:	singleTypeImportDeclaration
+	|	typeImportOnDemandDeclaration
+	|	singleStaticImportDeclaration
+	|	staticImportOnDemandDeclaration
+	;
+
+singleTypeImportDeclaration
+	:	'import' typeName ';'
+	;
+
+typeImportOnDemandDeclaration
+	:	'import' packageOrTypeName '.' '*' ';'
+	;
+
+singleStaticImportDeclaration
+	:	'import' 'static' typeName '.' Identifier ';'
+	;
+
+staticImportOnDemandDeclaration
+	:	'import' 'static' typeName '.' '*' ';'
+	;
+
+typeDeclaration
+	:	classDeclaration
+	|	interfaceDeclaration
+	|	';'
+	;
+
+/*
+ * Productions from §8 (Classes)
+ */
+
+classDeclaration
+	:	normalClassDeclaration
+	|	enumDeclaration
+	;
+
+normalClassDeclaration
+	:	classModifier* 'class' Identifier typeParameters? superclass? superinterfaces? classBody  # ClassName
+	;
+
+classModifier
+	:	annotation
+	|	'public'
+	|	'protected'
+	|	'private'
+	|	'abstract'
+	|	'static'
+	|	'final'
+	|	'strictfp'
+	;
+
+typeParameters
+	:	'<' typeParameterList '>'
+	;
+
+typeParameterList
+	:	typeParameter (',' typeParameter)*
+	;
+
+superclass
+	:	'extends' classType
+	;
+
+superinterfaces
+	:	'implements' interfaceTypeList
+	;
+
+interfaceTypeList
+	:	interfaceType (',' interfaceType)*
+	;
+
+classBody
+	:	'{' classBodyDeclaration* '}'
+	;
+
+classBodyDeclaration
+	:	classMemberDeclaration
+	|	instanceInitializer
+	|	staticInitializer
+	|	constructorDeclaration
+	;
+
+classMemberDeclaration
+	:	fieldDeclaration
+	|	methodDeclaration
+	|	classDeclaration
+	|	interfaceDeclaration
+	|	';'
+	;
+
+fieldDeclaration
+	:	.+? ';'
+	;
+
+variableDeclaratorId
+	:	Identifier dims?
+	;
+
+variableInitializer
+	:	expression
+	|	arrayInitializer
+	;
+
+unannType
+	:	unannPrimitiveType
+	|	unannReferenceType
+	;
+
+unannPrimitiveType
+	:	numericType
+	|	'boolean'
+	;
+
+unannReferenceType
+	:	unannClassOrInterfaceType
+	|	unannTypeVariable
+	|	unannArrayType
+	;
+
+unannClassOrInterfaceType
+	:	(	unannClassType_lfno_unannClassOrInterfaceType
+		|	unannInterfaceType_lfno_unannClassOrInterfaceType
+		)
+		(	unannClassType_lf_unannClassOrInterfaceType
+		|	unannInterfaceType_lf_unannClassOrInterfaceType
+		)*
+	;
+
+unannClassType_lf_unannClassOrInterfaceType
+	:	'.' annotation* Identifier typeArguments?
+	;
+
+unannClassType_lfno_unannClassOrInterfaceType
+	:	Identifier typeArguments?
+	;
+
+unannInterfaceType_lf_unannClassOrInterfaceType
+	:	unannClassType_lf_unannClassOrInterfaceType
+	;
+
+unannInterfaceType_lfno_unannClassOrInterfaceType
+	:	unannClassType_lfno_unannClassOrInterfaceType
+	;
+
+unannTypeVariable
+	:	Identifier
+	;
+
+unannArrayType
+	:	unannPrimitiveType dims
+	|	unannClassOrInterfaceType dims
+	|	unannTypeVariable dims
+	;
+
+methodDeclaration
+	:	methodModifier* methodHeader methodBody
+	;
+
+methodModifier
+	:	annotation
+	|	'public'
+	|	'protected'
+	|	'private'
+	|	'abstract'
+	|	'static'
+	|	'final'
+	|	'synchronized'
+	|	'native'
+	|	'strictfp'
+	;
+
+methodHeader
+	:	result methodDeclarator throws_?
+	|	typeParameters annotation* result methodDeclarator throws_?
+	;
+
+result
+	:	unannType
+	|	'void'
+	;
+
+methodDeclarator
+	:	Identifier '(' formalParameterList? ')' dims?               # MethodName
+	;
+
+formalParameterList
+	:	formalParameters ',' lastFormalParameter
+	|	lastFormalParameter
+	;
+
+formalParameters
+	:	formalParameter (',' formalParameter)*
+	|	receiverParameter (',' formalParameter)*
+	;
+
+formalParameter
+	:	variableModifier* unannType variableDeclaratorId
+	;
+
+variableModifier
+	:	annotation
+	|	'final'
+	;
+
+lastFormalParameter
+	:	variableModifier* unannType annotation* '...' variableDeclaratorId
+	|	formalParameter
+	;
+
+receiverParameter
+	:	annotation* unannType (Identifier '.')? 'this'
+	;
+
+throws_
+	:	'throws' exceptionTypeList
+	;
+
+exceptionTypeList
+	:	exceptionType (',' exceptionType)*
+	;
+
+exceptionType
+	:	classType
+	|	typeVariable
+	;
+
+methodBody
+	:	block
+	|	';'
+	;
+
+instanceInitializer
+	:	block
+	;
+
+staticInitializer
+	:	'static' block
+	;
+
+constructorDeclaration
+	:	constructorModifier* constructorDeclarator throws_? constructorBody
+	;
+
+constructorModifier
+	:	annotation
+	|	'public'
+	|	'protected'
+	|	'private'
+	;
+
+constructorDeclarator
+	:	typeParameters? simpleTypeName '(' formalParameterList? ')'
+	;
+
+simpleTypeName
+	:	Identifier                              # ConstructorName
+	;
+
+constructorBody
+	:	'{' explicitConstructorInvocation? blockStatements? '}'
+	;
+
+explicitConstructorInvocation
+	:	typeArguments? 'this' '(' argumentList? ')' ';'
+	|	typeArguments? 'super' '(' argumentList? ')' ';'
+	|	expressionName '.' typeArguments? 'super' '(' argumentList? ')' ';'
+	|	primary '.' typeArguments? 'super' '(' argumentList? ')' ';'
+	;
+
+enumDeclaration
+	:	classModifier* 'enum' Identifier superinterfaces? enumBody              # EnumName
+	;
+
+enumBody
+	:	'{' enumConstantList? ','? enumBodyDeclarations? '}'
+	;
+
+enumConstantList
+	:	enumConstant (',' enumConstant)*
+	;
+
+enumConstant
+	:	enumConstantModifier* Identifier ('(' argumentList? ')')? classBody?
+	;
+
+enumConstantModifier
+	:	annotation
+	;
+
+enumBodyDeclarations
+	:	';' classBodyDeclaration*
+	;
+
+argumentList
+	:	expression (',' expression)*
+	;
+
+/*
+ * Lite grammar stubs
+ */
+
+expression
+        :       .+?
+        ;
+
+conditionalExpression
+        :       .+?
+        ;
+
+primary
+	    :       .+?
+        ;
+/* primary
+	:	(	primaryNoNewArray_lfno_primary
+		|	arrayCreationExpression
+		)
+		(	primaryNoNewArray_lf_primary
+		)*
+	; */
+
+/*
+ * Productions from §9 (Interfaces)
+ */
+
+interfaceDeclaration
+	:	normalInterfaceDeclaration
+	|	annotationTypeDeclaration
+	;
+
+normalInterfaceDeclaration
+	:	interfaceModifier* 'interface' Identifier typeParameters? extendsInterfaces? interfaceBody  # IfaceName
+	;
+
+interfaceModifier
+	:	annotation
+	|	'public'
+	|	'protected'
+	|	'private'
+	|	'abstract'
+	|	'static'
+	|	'strictfp'
+	;
+
+extendsInterfaces
+	:	'extends' interfaceTypeList
+	;
+
+interfaceBody
+	:	'{' interfaceMemberDeclaration* '}'
+	;
+
+interfaceMemberDeclaration
+	:	constantDeclaration
+	|	interfaceMethodDeclaration
+	|	classDeclaration
+	|	interfaceDeclaration
+	|	';'
+	;
+
+constantDeclaration
+	:	constantModifier* unannType .+? ';' // constantModifier* unannType variableDeclaratorList ';'
+	;
+
+constantModifier
+	:	annotation
+	|	'public'
+	|	'static'
+	|	'final'
+	;
+
+interfaceMethodDeclaration
+	:	interfaceMethodModifier* methodHeader methodBody
+	;
+
+interfaceMethodModifier
+	:	annotation
+	|	'public'
+	|	'abstract'
+	|	'default'
+	|	'static'
+	|	'strictfp'
+	;
+
+annotationTypeDeclaration
+	:	interfaceModifier* '@' 'interface' Identifier annotationTypeBody            # AnnoName
+	;
+
+annotationTypeBody
+	:	'{' .+? '}'            // '{' annotationTypeMemberDeclaration* '}'
+	;
+
+annotation
+	:	normalAnnotation
+	|	markerAnnotation
+	|	singleElementAnnotation
+	;
+
+normalAnnotation
+	:	'@' typeName '(' elementValuePairList? ')'
+	;
+
+elementValuePairList
+	:	elementValuePair (',' elementValuePair)*
+	;
+
+elementValuePair
+	:	Identifier '=' elementValue
+	;
+
+elementValue
+	:	conditionalExpression
+	|	elementValueArrayInitializer
+	|	annotation
+	;
+
+elementValueArrayInitializer
+	:	'{' elementValueList? ','? '}'
+	;
+
+elementValueList
+	:	elementValue (',' elementValue)*
+	;
+
+markerAnnotation
+	:	'@' typeName
+	;
+
+singleElementAnnotation
+	:	'@' typeName '(' elementValue ')'
+	;
+
+/*
+ * Productions from §10 (Arrays)
+ */
+
+arrayInitializer
+	:	'{' variableInitializerList? ','? '}'
+	;
+
+variableInitializerList
+	:	variableInitializer (',' variableInitializer)*
+	;
+
+/*
+ * Productions from §14 (Blocks and Statements)
+ */
+
+block
+	:	'{' blockStatements? '}'
+	;
+
+blockStatements
+	:	.+?
+	;
+
+/*
+ * Productions from §15 (Expressions)
+ */
+
+// LEXER
+
+// §3.9 Keywords
+
+ABSTRACT : 'abstract';
+ASSERT : 'assert';
+BOOLEAN : 'boolean';
+BREAK : 'break';
+BYTE : 'byte';
+CASE : 'case';
+CATCH : 'catch';
+CHAR : 'char';
+CLASS : 'class';
+CONST : 'const';
+CONTINUE : 'continue';
+DEFAULT : 'default';
+DO : 'do';
+DOUBLE : 'double';
+ELSE : 'else';
+ENUM : 'enum';
+EXTENDS : 'extends';
+FINAL : 'final';
+FINALLY : 'finally';
+FLOAT : 'float';
+FOR : 'for';
+IF : 'if';
+GOTO : 'goto';
+IMPLEMENTS : 'implements';
+IMPORT : 'import';
+INSTANCEOF : 'instanceof';
+INT : 'int';
+INTERFACE : 'interface';
+LONG : 'long';
+NATIVE : 'native';
+NEW : 'new';
+PACKAGE : 'package';
+PRIVATE : 'private';
+PROTECTED : 'protected';
+PUBLIC : 'public';
+RETURN : 'return';
+SHORT : 'short';
+STATIC : 'static';
+STRICTFP : 'strictfp';
+SUPER : 'super';
+SWITCH : 'switch';
+SYNCHRONIZED : 'synchronized';
+THIS : 'this';
+THROW : 'throw';
+THROWS : 'throws';
+TRANSIENT : 'transient';
+TRY : 'try';
+VOID : 'void';
+VOLATILE : 'volatile';
+WHILE : 'while';
+
+// §3.10.1 Integer Literals
+
+IntegerLiteral
+	:	DecimalIntegerLiteral
+	|	HexIntegerLiteral
+	|	OctalIntegerLiteral
+	|	BinaryIntegerLiteral
+	;
+
+fragment
+DecimalIntegerLiteral
+	:	DecimalNumeral IntegerTypeSuffix?
+	;
+
+fragment
+HexIntegerLiteral
+	:	HexNumeral IntegerTypeSuffix?
+	;
+
+fragment
+OctalIntegerLiteral
+	:	OctalNumeral IntegerTypeSuffix?
+	;
+
+fragment
+BinaryIntegerLiteral
+	:	BinaryNumeral IntegerTypeSuffix?
+	;
+
+fragment
+IntegerTypeSuffix
+	:	[lL]
+	;
+
+fragment
+DecimalNumeral
+	:	'0'
+	|	NonZeroDigit (Digits? | Underscores Digits)
+	;
+
+fragment
+Digits
+	:	Digit (DigitsAndUnderscores? Digit)?
+	;
+
+fragment
+Digit
+	:	'0'
+	|	NonZeroDigit
+	;
+
+fragment
+NonZeroDigit
+	:	[1-9]
+	;
+
+fragment
+DigitsAndUnderscores
+	:	DigitOrUnderscore+
+	;
+
+fragment
+DigitOrUnderscore
+	:	Digit
+	|	'_'
+	;
+
+fragment
+Underscores
+	:	'_'+
+	;
+
+fragment
+HexNumeral
+	:	'0' [xX] HexDigits
+	;
+
+fragment
+HexDigits
+	:	HexDigit (HexDigitsAndUnderscores? HexDigit)?
+	;
+
+fragment
+HexDigit
+	:	[0-9a-fA-F]
+	;
+
+fragment
+HexDigitsAndUnderscores
+	:	HexDigitOrUnderscore+
+	;
+
+fragment
+HexDigitOrUnderscore
+	:	HexDigit
+	|	'_'
+	;
+
+fragment
+OctalNumeral
+	:	'0' Underscores? OctalDigits
+	;
+
+fragment
+OctalDigits
+	:	OctalDigit (OctalDigitsAndUnderscores? OctalDigit)?
+	;
+
+fragment
+OctalDigit
+	:	[0-7]
+	;
+
+fragment
+OctalDigitsAndUnderscores
+	:	OctalDigitOrUnderscore+
+	;
+
+fragment
+OctalDigitOrUnderscore
+	:	OctalDigit
+	|	'_'
+	;
+
+fragment
+BinaryNumeral
+	:	'0' [bB] BinaryDigits
+	;
+
+fragment
+BinaryDigits
+	:	BinaryDigit (BinaryDigitsAndUnderscores? BinaryDigit)?
+	;
+
+fragment
+BinaryDigit
+	:	[01]
+	;
+
+fragment
+BinaryDigitsAndUnderscores
+	:	BinaryDigitOrUnderscore+
+	;
+
+fragment
+BinaryDigitOrUnderscore
+	:	BinaryDigit
+	|	'_'
+	;
+
+// §3.10.2 Floating-Point Literals
+
+FloatingPointLiteral
+	:	DecimalFloatingPointLiteral
+	|	HexadecimalFloatingPointLiteral
+	;
+
+fragment
+DecimalFloatingPointLiteral
+	:	Digits '.' Digits? ExponentPart? FloatTypeSuffix?
+	|	'.' Digits ExponentPart? FloatTypeSuffix?
+	|	Digits ExponentPart FloatTypeSuffix?
+	|	Digits FloatTypeSuffix
+	;
+
+fragment
+ExponentPart
+	:	ExponentIndicator SignedInteger
+	;
+
+fragment
+ExponentIndicator
+	:	[eE]
+	;
+
+fragment
+SignedInteger
+	:	Sign? Digits
+	;
+
+fragment
+Sign
+	:	[+-]
+	;
+
+fragment
+FloatTypeSuffix
+	:	[fFdD]
+	;
+
+fragment
+HexadecimalFloatingPointLiteral
+	:	HexSignificand BinaryExponent FloatTypeSuffix?
+	;
+
+fragment
+HexSignificand
+	:	HexNumeral '.'?
+	|	'0' [xX] HexDigits? '.' HexDigits
+	;
+
+fragment
+BinaryExponent
+	:	BinaryExponentIndicator SignedInteger
+	;
+
+fragment
+BinaryExponentIndicator
+	:	[pP]
+	;
+
+// §3.10.3 Boolean Literals
+
+BooleanLiteral
+	:	'true'
+	|	'false'
+	;
+
+// §3.10.4 Character Literals
+
+CharacterLiteral
+	:	'\'' SingleCharacter '\''
+	|	'\'' EscapeSequence '\''
+	;
+
+fragment
+SingleCharacter
+	:	~['\\]
+	;
+
+// §3.10.5 String Literals
+
+StringLiteral
+	:	'"' StringCharacters? '"'
+	;
+
+fragment
+StringCharacters
+	:	StringCharacter+
+	;
+
+fragment
+StringCharacter
+	:	~["\\]
+	|	EscapeSequence
+	;
+
+// §3.10.6 Escape Sequences for Character and String Literals
+
+fragment
+EscapeSequence
+	:	'\\' [btnfr"'\\]
+	|	OctalEscape
+    |   UnicodeEscape // This is not in the spec but prevents having to preprocess the input
+	;
+
+fragment
+OctalEscape
+	:	'\\' OctalDigit
+	|	'\\' OctalDigit OctalDigit
+	|	'\\' ZeroToThree OctalDigit OctalDigit
+	;
+
+fragment
+ZeroToThree
+	:	[0-3]
+	;
+
+// This is not in the spec but prevents having to preprocess the input
+fragment
+UnicodeEscape
+    :   '\\' 'u' HexDigit HexDigit HexDigit HexDigit
+    ;
+
+// §3.10.7 The Null Literal
+
+NullLiteral
+	:	'null'
+	;
+
+// §3.11 Separators
+
+LPAREN : '(';
+RPAREN : ')';
+LBRACE : '{';
+RBRACE : '}';
+LBRACK : '[';
+RBRACK : ']';
+SEMI : ';';
+COMMA : ',';
+DOT : '.';
+
+// §3.12 Operators
+
+ASSIGN : '=';
+GT : '>';
+LT : '<';
+BANG : '!';
+TILDE : '~';
+QUESTION : '?';
+COLON : ':';
+EQUAL : '==';
+LE : '<=';
+GE : '>=';
+NOTEQUAL : '!=';
+AND : '&&';
+OR : '||';
+INC : '++';
+DEC : '--';
+ADD : '+';
+SUB : '-';
+MUL : '*';
+DIV : '/';
+BITAND : '&';
+BITOR : '|';
+CARET : '^';
+MOD : '%';
+ARROW : '->';
+COLONCOLON : '::';
+
+ADD_ASSIGN : '+=';
+SUB_ASSIGN : '-=';
+MUL_ASSIGN : '*=';
+DIV_ASSIGN : '/=';
+AND_ASSIGN : '&=';
+OR_ASSIGN : '|=';
+XOR_ASSIGN : '^=';
+MOD_ASSIGN : '%=';
+LSHIFT_ASSIGN : '<<=';
+RSHIFT_ASSIGN : '>>=';
+URSHIFT_ASSIGN : '>>>=';
+
+// §3.8 Identifiers (must appear after all keywords in the grammar)
+
+Identifier
+	:	JavaLetter JavaLetterOrDigit*
+	;
+
+fragment
+JavaLetter
+	:	[a-zA-Z$_] // these are the "java letters" below 0x7F
+	|	// covers all characters above 0x7F which are not a surrogate
+		~[\u0000-\u007F\uD800-\uDBFF]
+		{Character.isJavaIdentifierStart(_input.LA(-1))}?
+	|	// covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF
+		[\uD800-\uDBFF] [\uDC00-\uDFFF]
+		{Character.isJavaIdentifierStart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1)))}?
+	;
+
+fragment
+JavaLetterOrDigit
+	:	[a-zA-Z0-9$_] // these are the "java letters or digits" below 0x7F
+	|	// covers all characters above 0x7F which are not a surrogate
+		~[\u0000-\u007F\uD800-\uDBFF]
+		{Character.isJavaIdentifierPart(_input.LA(-1))}?
+	|	// covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF
+		[\uD800-\uDBFF] [\uDC00-\uDFFF]
+		{Character.isJavaIdentifierPart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1)))}?
+	;
+
+//
+// Additional symbols not defined in the lexical specification
+//
+
+AT : '@';
+ELLIPSIS : '...';
+
+//
+// Whitespace and comments
+//
+
+WS  :  [ \t\r\n\u000C]+ -> skip
+    ;
+
+COMMENT
+    :   '/*' .*? '*/' -> skip
+    ;
+
+LINE_COMMENT
+    :   '//' ~[\r\n]* -> skip
+    ;
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJava.tokens b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJava.tokens
new file mode 100644
index 0000000..52ef1ee
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJava.tokens
@@ -0,0 +1,205 @@
+ABSTRACT=1
+ASSERT=2
+BOOLEAN=3
+BREAK=4
+BYTE=5
+CASE=6
+CATCH=7
+CHAR=8
+CLASS=9
+CONST=10
+CONTINUE=11
+DEFAULT=12
+DO=13
+DOUBLE=14
+ELSE=15
+ENUM=16
+EXTENDS=17
+FINAL=18
+FINALLY=19
+FLOAT=20
+FOR=21
+IF=22
+GOTO=23
+IMPLEMENTS=24
+IMPORT=25
+INSTANCEOF=26
+INT=27
+INTERFACE=28
+LONG=29
+NATIVE=30
+NEW=31
+PACKAGE=32
+PRIVATE=33
+PROTECTED=34
+PUBLIC=35
+RETURN=36
+SHORT=37
+STATIC=38
+STRICTFP=39
+SUPER=40
+SWITCH=41
+SYNCHRONIZED=42
+THIS=43
+THROW=44
+THROWS=45
+TRANSIENT=46
+TRY=47
+VOID=48
+VOLATILE=49
+WHILE=50
+IntegerLiteral=51
+FloatingPointLiteral=52
+BooleanLiteral=53
+CharacterLiteral=54
+StringLiteral=55
+NullLiteral=56
+LPAREN=57
+RPAREN=58
+LBRACE=59
+RBRACE=60
+LBRACK=61
+RBRACK=62
+SEMI=63
+COMMA=64
+DOT=65
+ASSIGN=66
+GT=67
+LT=68
+BANG=69
+TILDE=70
+QUESTION=71
+COLON=72
+EQUAL=73
+LE=74
+GE=75
+NOTEQUAL=76
+AND=77
+OR=78
+INC=79
+DEC=80
+ADD=81
+SUB=82
+MUL=83
+DIV=84
+BITAND=85
+BITOR=86
+CARET=87
+MOD=88
+ARROW=89
+COLONCOLON=90
+ADD_ASSIGN=91
+SUB_ASSIGN=92
+MUL_ASSIGN=93
+DIV_ASSIGN=94
+AND_ASSIGN=95
+OR_ASSIGN=96
+XOR_ASSIGN=97
+MOD_ASSIGN=98
+LSHIFT_ASSIGN=99
+RSHIFT_ASSIGN=100
+URSHIFT_ASSIGN=101
+Identifier=102
+AT=103
+ELLIPSIS=104
+WS=105
+COMMENT=106
+LINE_COMMENT=107
+'abstract'=1
+'assert'=2
+'boolean'=3
+'break'=4
+'byte'=5
+'case'=6
+'catch'=7
+'char'=8
+'class'=9
+'const'=10
+'continue'=11
+'default'=12
+'do'=13
+'double'=14
+'else'=15
+'enum'=16
+'extends'=17
+'final'=18
+'finally'=19
+'float'=20
+'for'=21
+'if'=22
+'goto'=23
+'implements'=24
+'import'=25
+'instanceof'=26
+'int'=27
+'interface'=28
+'long'=29
+'native'=30
+'new'=31
+'package'=32
+'private'=33
+'protected'=34
+'public'=35
+'return'=36
+'short'=37
+'static'=38
+'strictfp'=39
+'super'=40
+'switch'=41
+'synchronized'=42
+'this'=43
+'throw'=44
+'throws'=45
+'transient'=46
+'try'=47
+'void'=48
+'volatile'=49
+'while'=50
+'null'=56
+'('=57
+')'=58
+'{'=59
+'}'=60
+'['=61
+']'=62
+';'=63
+','=64
+'.'=65
+'='=66
+'>'=67
+'<'=68
+'!'=69
+'~'=70
+'?'=71
+':'=72
+'=='=73
+'<='=74
+'>='=75
+'!='=76
+'&&'=77
+'||'=78
+'++'=79
+'--'=80
+'+'=81
+'-'=82
+'*'=83
+'/'=84
+'&'=85
+'|'=86
+'^'=87
+'%'=88
+'->'=89
+'::'=90
+'+='=91
+'-='=92
+'*='=93
+'/='=94
+'&='=95
+'|='=96
+'^='=97
+'%='=98
+'<<='=99
+'>>='=100
+'>>>='=101
+'@'=103
+'...'=104
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java
new file mode 100644
index 0000000..8b45b8d
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java
@@ -0,0 +1,1467 @@
+// Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\DroppingJava.g4 by ANTLR 4.5.1
+package ru.ftc.upc.testing.dropper.lang.gen;
+
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.tree.ErrorNode;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+/**
+ * This class provides an empty implementation of {@link DroppingJavaListener},
+ * which can be extended to create a listener which only needs to handle a subset
+ * of the available methods.
+ */
+public class DroppingJavaBaseListener implements DroppingJavaListener {
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterPrimitiveType(DroppingJavaParser.PrimitiveTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitPrimitiveType(DroppingJavaParser.PrimitiveTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterNumericType(DroppingJavaParser.NumericTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitNumericType(DroppingJavaParser.NumericTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterIntegralType(DroppingJavaParser.IntegralTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitIntegralType(DroppingJavaParser.IntegralTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterFloatingPointType(DroppingJavaParser.FloatingPointTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitFloatingPointType(DroppingJavaParser.FloatingPointTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterReferenceType(DroppingJavaParser.ReferenceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitReferenceType(DroppingJavaParser.ReferenceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterClassOrInterfaceType(DroppingJavaParser.ClassOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitClassOrInterfaceType(DroppingJavaParser.ClassOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterClassType(DroppingJavaParser.ClassTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitClassType(DroppingJavaParser.ClassTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterClassType_lf_classOrInterfaceType(DroppingJavaParser.ClassType_lf_classOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitClassType_lf_classOrInterfaceType(DroppingJavaParser.ClassType_lf_classOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterClassType_lfno_classOrInterfaceType(DroppingJavaParser.ClassType_lfno_classOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitClassType_lfno_classOrInterfaceType(DroppingJavaParser.ClassType_lfno_classOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInterfaceType(DroppingJavaParser.InterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInterfaceType(DroppingJavaParser.InterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInterfaceType_lf_classOrInterfaceType(DroppingJavaParser.InterfaceType_lf_classOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInterfaceType_lf_classOrInterfaceType(DroppingJavaParser.InterfaceType_lf_classOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInterfaceType_lfno_classOrInterfaceType(DroppingJavaParser.InterfaceType_lfno_classOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInterfaceType_lfno_classOrInterfaceType(DroppingJavaParser.InterfaceType_lfno_classOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeVariable(DroppingJavaParser.TypeVariableContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeVariable(DroppingJavaParser.TypeVariableContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterArrayType(DroppingJavaParser.ArrayTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitArrayType(DroppingJavaParser.ArrayTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterDims(DroppingJavaParser.DimsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitDims(DroppingJavaParser.DimsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeParameter(DroppingJavaParser.TypeParameterContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeParameter(DroppingJavaParser.TypeParameterContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeParameterModifier(DroppingJavaParser.TypeParameterModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeParameterModifier(DroppingJavaParser.TypeParameterModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeBound(DroppingJavaParser.TypeBoundContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeBound(DroppingJavaParser.TypeBoundContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAdditionalBound(DroppingJavaParser.AdditionalBoundContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAdditionalBound(DroppingJavaParser.AdditionalBoundContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeArguments(DroppingJavaParser.TypeArgumentsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeArguments(DroppingJavaParser.TypeArgumentsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeArgumentList(DroppingJavaParser.TypeArgumentListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeArgumentList(DroppingJavaParser.TypeArgumentListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeArgument(DroppingJavaParser.TypeArgumentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeArgument(DroppingJavaParser.TypeArgumentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterWildcard(DroppingJavaParser.WildcardContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitWildcard(DroppingJavaParser.WildcardContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterWildcardBounds(DroppingJavaParser.WildcardBoundsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitWildcardBounds(DroppingJavaParser.WildcardBoundsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeName(DroppingJavaParser.TypeNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeName(DroppingJavaParser.TypeNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterPackageOrTypeName(DroppingJavaParser.PackageOrTypeNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitPackageOrTypeName(DroppingJavaParser.PackageOrTypeNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterExpressionName(DroppingJavaParser.ExpressionNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitExpressionName(DroppingJavaParser.ExpressionNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAmbiguousName(DroppingJavaParser.AmbiguousNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAmbiguousName(DroppingJavaParser.AmbiguousNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterCompilationUnit(DroppingJavaParser.CompilationUnitContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitCompilationUnit(DroppingJavaParser.CompilationUnitContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterPackageDeclaration(DroppingJavaParser.PackageDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitPackageDeclaration(DroppingJavaParser.PackageDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterPackageModifier(DroppingJavaParser.PackageModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitPackageModifier(DroppingJavaParser.PackageModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterImportDeclaration(DroppingJavaParser.ImportDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitImportDeclaration(DroppingJavaParser.ImportDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterSingleTypeImportDeclaration(DroppingJavaParser.SingleTypeImportDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitSingleTypeImportDeclaration(DroppingJavaParser.SingleTypeImportDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeImportOnDemandDeclaration(DroppingJavaParser.TypeImportOnDemandDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeImportOnDemandDeclaration(DroppingJavaParser.TypeImportOnDemandDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterSingleStaticImportDeclaration(DroppingJavaParser.SingleStaticImportDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitSingleStaticImportDeclaration(DroppingJavaParser.SingleStaticImportDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterStaticImportOnDemandDeclaration(DroppingJavaParser.StaticImportOnDemandDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitStaticImportOnDemandDeclaration(DroppingJavaParser.StaticImportOnDemandDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeDeclaration(DroppingJavaParser.TypeDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeDeclaration(DroppingJavaParser.TypeDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterClassDeclaration(DroppingJavaParser.ClassDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitClassDeclaration(DroppingJavaParser.ClassDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterClassName(DroppingJavaParser.ClassNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitClassName(DroppingJavaParser.ClassNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterClassModifier(DroppingJavaParser.ClassModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitClassModifier(DroppingJavaParser.ClassModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeParameters(DroppingJavaParser.TypeParametersContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeParameters(DroppingJavaParser.TypeParametersContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeParameterList(DroppingJavaParser.TypeParameterListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeParameterList(DroppingJavaParser.TypeParameterListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterSuperclass(DroppingJavaParser.SuperclassContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitSuperclass(DroppingJavaParser.SuperclassContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterSuperinterfaces(DroppingJavaParser.SuperinterfacesContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitSuperinterfaces(DroppingJavaParser.SuperinterfacesContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInterfaceTypeList(DroppingJavaParser.InterfaceTypeListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInterfaceTypeList(DroppingJavaParser.InterfaceTypeListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterClassBody(DroppingJavaParser.ClassBodyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitClassBody(DroppingJavaParser.ClassBodyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterClassBodyDeclaration(DroppingJavaParser.ClassBodyDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitClassBodyDeclaration(DroppingJavaParser.ClassBodyDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterClassMemberDeclaration(DroppingJavaParser.ClassMemberDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitClassMemberDeclaration(DroppingJavaParser.ClassMemberDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterFieldDeclaration(DroppingJavaParser.FieldDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitFieldDeclaration(DroppingJavaParser.FieldDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterVariableDeclaratorId(DroppingJavaParser.VariableDeclaratorIdContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitVariableDeclaratorId(DroppingJavaParser.VariableDeclaratorIdContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterVariableInitializer(DroppingJavaParser.VariableInitializerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitVariableInitializer(DroppingJavaParser.VariableInitializerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterUnannType(DroppingJavaParser.UnannTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitUnannType(DroppingJavaParser.UnannTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterUnannPrimitiveType(DroppingJavaParser.UnannPrimitiveTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitUnannPrimitiveType(DroppingJavaParser.UnannPrimitiveTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterUnannReferenceType(DroppingJavaParser.UnannReferenceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitUnannReferenceType(DroppingJavaParser.UnannReferenceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterUnannClassOrInterfaceType(DroppingJavaParser.UnannClassOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitUnannClassOrInterfaceType(DroppingJavaParser.UnannClassOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterUnannClassType_lf_unannClassOrInterfaceType(DroppingJavaParser.UnannClassType_lf_unannClassOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitUnannClassType_lf_unannClassOrInterfaceType(DroppingJavaParser.UnannClassType_lf_unannClassOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterUnannClassType_lfno_unannClassOrInterfaceType(DroppingJavaParser.UnannClassType_lfno_unannClassOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitUnannClassType_lfno_unannClassOrInterfaceType(DroppingJavaParser.UnannClassType_lfno_unannClassOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterUnannInterfaceType_lf_unannClassOrInterfaceType(DroppingJavaParser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitUnannInterfaceType_lf_unannClassOrInterfaceType(DroppingJavaParser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterUnannInterfaceType_lfno_unannClassOrInterfaceType(DroppingJavaParser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitUnannInterfaceType_lfno_unannClassOrInterfaceType(DroppingJavaParser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterUnannTypeVariable(DroppingJavaParser.UnannTypeVariableContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitUnannTypeVariable(DroppingJavaParser.UnannTypeVariableContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterUnannArrayType(DroppingJavaParser.UnannArrayTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitUnannArrayType(DroppingJavaParser.UnannArrayTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMethodDeclaration(DroppingJavaParser.MethodDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMethodDeclaration(DroppingJavaParser.MethodDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMethodModifier(DroppingJavaParser.MethodModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMethodModifier(DroppingJavaParser.MethodModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMethodHeader(DroppingJavaParser.MethodHeaderContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMethodHeader(DroppingJavaParser.MethodHeaderContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterResult(DroppingJavaParser.ResultContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitResult(DroppingJavaParser.ResultContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMethodName(DroppingJavaParser.MethodNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMethodName(DroppingJavaParser.MethodNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterFormalParameterList(DroppingJavaParser.FormalParameterListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitFormalParameterList(DroppingJavaParser.FormalParameterListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterFormalParameters(DroppingJavaParser.FormalParametersContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitFormalParameters(DroppingJavaParser.FormalParametersContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterFormalParameter(DroppingJavaParser.FormalParameterContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitFormalParameter(DroppingJavaParser.FormalParameterContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterVariableModifier(DroppingJavaParser.VariableModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitVariableModifier(DroppingJavaParser.VariableModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterLastFormalParameter(DroppingJavaParser.LastFormalParameterContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitLastFormalParameter(DroppingJavaParser.LastFormalParameterContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterReceiverParameter(DroppingJavaParser.ReceiverParameterContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitReceiverParameter(DroppingJavaParser.ReceiverParameterContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterThrows_(DroppingJavaParser.Throws_Context ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitThrows_(DroppingJavaParser.Throws_Context ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterExceptionTypeList(DroppingJavaParser.ExceptionTypeListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitExceptionTypeList(DroppingJavaParser.ExceptionTypeListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterExceptionType(DroppingJavaParser.ExceptionTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitExceptionType(DroppingJavaParser.ExceptionTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMethodBody(DroppingJavaParser.MethodBodyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMethodBody(DroppingJavaParser.MethodBodyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInstanceInitializer(DroppingJavaParser.InstanceInitializerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInstanceInitializer(DroppingJavaParser.InstanceInitializerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterStaticInitializer(DroppingJavaParser.StaticInitializerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitStaticInitializer(DroppingJavaParser.StaticInitializerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterConstructorDeclaration(DroppingJavaParser.ConstructorDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitConstructorDeclaration(DroppingJavaParser.ConstructorDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterConstructorModifier(DroppingJavaParser.ConstructorModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitConstructorModifier(DroppingJavaParser.ConstructorModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterConstructorDeclarator(DroppingJavaParser.ConstructorDeclaratorContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitConstructorDeclarator(DroppingJavaParser.ConstructorDeclaratorContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterConstructorName(DroppingJavaParser.ConstructorNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitConstructorName(DroppingJavaParser.ConstructorNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterConstructorBody(DroppingJavaParser.ConstructorBodyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitConstructorBody(DroppingJavaParser.ConstructorBodyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterExplicitConstructorInvocation(DroppingJavaParser.ExplicitConstructorInvocationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitExplicitConstructorInvocation(DroppingJavaParser.ExplicitConstructorInvocationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterEnumName(DroppingJavaParser.EnumNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitEnumName(DroppingJavaParser.EnumNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterEnumBody(DroppingJavaParser.EnumBodyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitEnumBody(DroppingJavaParser.EnumBodyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterEnumConstantList(DroppingJavaParser.EnumConstantListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitEnumConstantList(DroppingJavaParser.EnumConstantListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterEnumConstant(DroppingJavaParser.EnumConstantContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitEnumConstant(DroppingJavaParser.EnumConstantContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterEnumConstantModifier(DroppingJavaParser.EnumConstantModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitEnumConstantModifier(DroppingJavaParser.EnumConstantModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterEnumBodyDeclarations(DroppingJavaParser.EnumBodyDeclarationsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitEnumBodyDeclarations(DroppingJavaParser.EnumBodyDeclarationsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterArgumentList(DroppingJavaParser.ArgumentListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitArgumentList(DroppingJavaParser.ArgumentListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterExpression(DroppingJavaParser.ExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitExpression(DroppingJavaParser.ExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterConditionalExpression(DroppingJavaParser.ConditionalExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitConditionalExpression(DroppingJavaParser.ConditionalExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterPrimary(DroppingJavaParser.PrimaryContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitPrimary(DroppingJavaParser.PrimaryContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInterfaceDeclaration(DroppingJavaParser.InterfaceDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInterfaceDeclaration(DroppingJavaParser.InterfaceDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterIfaceName(DroppingJavaParser.IfaceNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitIfaceName(DroppingJavaParser.IfaceNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInterfaceModifier(DroppingJavaParser.InterfaceModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInterfaceModifier(DroppingJavaParser.InterfaceModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterExtendsInterfaces(DroppingJavaParser.ExtendsInterfacesContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitExtendsInterfaces(DroppingJavaParser.ExtendsInterfacesContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInterfaceBody(DroppingJavaParser.InterfaceBodyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInterfaceBody(DroppingJavaParser.InterfaceBodyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInterfaceMemberDeclaration(DroppingJavaParser.InterfaceMemberDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInterfaceMemberDeclaration(DroppingJavaParser.InterfaceMemberDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterConstantDeclaration(DroppingJavaParser.ConstantDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitConstantDeclaration(DroppingJavaParser.ConstantDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterConstantModifier(DroppingJavaParser.ConstantModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitConstantModifier(DroppingJavaParser.ConstantModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInterfaceMethodDeclaration(DroppingJavaParser.InterfaceMethodDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInterfaceMethodDeclaration(DroppingJavaParser.InterfaceMethodDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInterfaceMethodModifier(DroppingJavaParser.InterfaceMethodModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInterfaceMethodModifier(DroppingJavaParser.InterfaceMethodModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAnnoName(DroppingJavaParser.AnnoNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAnnoName(DroppingJavaParser.AnnoNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAnnotationTypeBody(DroppingJavaParser.AnnotationTypeBodyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAnnotationTypeBody(DroppingJavaParser.AnnotationTypeBodyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAnnotation(DroppingJavaParser.AnnotationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAnnotation(DroppingJavaParser.AnnotationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterNormalAnnotation(DroppingJavaParser.NormalAnnotationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitNormalAnnotation(DroppingJavaParser.NormalAnnotationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterElementValuePairList(DroppingJavaParser.ElementValuePairListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitElementValuePairList(DroppingJavaParser.ElementValuePairListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterElementValuePair(DroppingJavaParser.ElementValuePairContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitElementValuePair(DroppingJavaParser.ElementValuePairContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterElementValue(DroppingJavaParser.ElementValueContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitElementValue(DroppingJavaParser.ElementValueContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterElementValueArrayInitializer(DroppingJavaParser.ElementValueArrayInitializerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitElementValueArrayInitializer(DroppingJavaParser.ElementValueArrayInitializerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterElementValueList(DroppingJavaParser.ElementValueListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitElementValueList(DroppingJavaParser.ElementValueListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMarkerAnnotation(DroppingJavaParser.MarkerAnnotationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMarkerAnnotation(DroppingJavaParser.MarkerAnnotationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterSingleElementAnnotation(DroppingJavaParser.SingleElementAnnotationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitSingleElementAnnotation(DroppingJavaParser.SingleElementAnnotationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterArrayInitializer(DroppingJavaParser.ArrayInitializerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitArrayInitializer(DroppingJavaParser.ArrayInitializerContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterVariableInitializerList(DroppingJavaParser.VariableInitializerListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitVariableInitializerList(DroppingJavaParser.VariableInitializerListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterBlock(DroppingJavaParser.BlockContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitBlock(DroppingJavaParser.BlockContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterBlockStatements(DroppingJavaParser.BlockStatementsContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitBlockStatements(DroppingJavaParser.BlockStatementsContext ctx) { }
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterEveryRule(ParserRuleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitEveryRule(ParserRuleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void visitTerminal(TerminalNode node) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void visitErrorNode(ErrorNode node) { }
+}
\ No newline at end of file
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.java
new file mode 100644
index 0000000..bb9eab7
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.java
@@ -0,0 +1,583 @@
+// Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\DroppingJava.g4 by ANTLR 4.5.1
+package ru.ftc.upc.testing.dropper.lang.gen;
+
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.atn.ATN;
+import org.antlr.v4.runtime.atn.ATNDeserializer;
+import org.antlr.v4.runtime.atn.LexerATNSimulator;
+import org.antlr.v4.runtime.atn.PredictionContextCache;
+import org.antlr.v4.runtime.dfa.DFA;
+
+@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
+public class DroppingJavaLexer extends Lexer {
+	static { RuntimeMetaData.checkVersion("4.5.1", RuntimeMetaData.VERSION); }
+
+	protected static final DFA[] _decisionToDFA;
+	protected static final PredictionContextCache _sharedContextCache =
+		new PredictionContextCache();
+	public static final int
+		ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8, 
+		CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15, 
+		ENUM=16, EXTENDS=17, FINAL=18, FINALLY=19, FLOAT=20, FOR=21, IF=22, GOTO=23, 
+		IMPLEMENTS=24, IMPORT=25, INSTANCEOF=26, INT=27, INTERFACE=28, LONG=29, 
+		NATIVE=30, NEW=31, PACKAGE=32, PRIVATE=33, PROTECTED=34, PUBLIC=35, RETURN=36, 
+		SHORT=37, STATIC=38, STRICTFP=39, SUPER=40, SWITCH=41, SYNCHRONIZED=42, 
+		THIS=43, THROW=44, THROWS=45, TRANSIENT=46, TRY=47, VOID=48, VOLATILE=49, 
+		WHILE=50, IntegerLiteral=51, FloatingPointLiteral=52, BooleanLiteral=53, 
+		CharacterLiteral=54, StringLiteral=55, NullLiteral=56, LPAREN=57, RPAREN=58, 
+		LBRACE=59, RBRACE=60, LBRACK=61, RBRACK=62, SEMI=63, COMMA=64, DOT=65, 
+		ASSIGN=66, GT=67, LT=68, BANG=69, TILDE=70, QUESTION=71, COLON=72, EQUAL=73, 
+		LE=74, GE=75, NOTEQUAL=76, AND=77, OR=78, INC=79, DEC=80, ADD=81, SUB=82, 
+		MUL=83, DIV=84, BITAND=85, BITOR=86, CARET=87, MOD=88, ARROW=89, COLONCOLON=90, 
+		ADD_ASSIGN=91, SUB_ASSIGN=92, MUL_ASSIGN=93, DIV_ASSIGN=94, AND_ASSIGN=95, 
+		OR_ASSIGN=96, XOR_ASSIGN=97, MOD_ASSIGN=98, LSHIFT_ASSIGN=99, RSHIFT_ASSIGN=100, 
+		URSHIFT_ASSIGN=101, Identifier=102, AT=103, ELLIPSIS=104, WS=105, COMMENT=106, 
+		LINE_COMMENT=107;
+	public static String[] modeNames = {
+		"DEFAULT_MODE"
+	};
+
+	public static final String[] ruleNames = {
+		"ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", "CHAR", 
+		"CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM", 
+		"EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", 
+		"IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", 
+		"PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", 
+		"SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", 
+		"TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "DecimalIntegerLiteral", 
+		"HexIntegerLiteral", "OctalIntegerLiteral", "BinaryIntegerLiteral", "IntegerTypeSuffix", 
+		"DecimalNumeral", "Digits", "Digit", "NonZeroDigit", "DigitsAndUnderscores", 
+		"DigitOrUnderscore", "Underscores", "HexNumeral", "HexDigits", "HexDigit", 
+		"HexDigitsAndUnderscores", "HexDigitOrUnderscore", "OctalNumeral", "OctalDigits", 
+		"OctalDigit", "OctalDigitsAndUnderscores", "OctalDigitOrUnderscore", "BinaryNumeral", 
+		"BinaryDigits", "BinaryDigit", "BinaryDigitsAndUnderscores", "BinaryDigitOrUnderscore", 
+		"FloatingPointLiteral", "DecimalFloatingPointLiteral", "ExponentPart", 
+		"ExponentIndicator", "SignedInteger", "Sign", "FloatTypeSuffix", "HexadecimalFloatingPointLiteral", 
+		"HexSignificand", "BinaryExponent", "BinaryExponentIndicator", "BooleanLiteral", 
+		"CharacterLiteral", "SingleCharacter", "StringLiteral", "StringCharacters", 
+		"StringCharacter", "EscapeSequence", "OctalEscape", "ZeroToThree", "UnicodeEscape", 
+		"NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", 
+		"SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", 
+		"COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", 
+		"SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", 
+		"ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", 
+		"OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", 
+		"URSHIFT_ASSIGN", "Identifier", "JavaLetter", "JavaLetterOrDigit", "AT", 
+		"ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT"
+	};
+
+	private static final String[] _LITERAL_NAMES = {
+		null, "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", "'case'", 
+		"'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", 
+		"'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", 
+		"'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", 
+		"'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", 
+		"'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", 
+		"'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", 
+		"'transient'", "'try'", "'void'", "'volatile'", "'while'", null, null, 
+		null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", 
+		"';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", 
+		"'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", 
+		"'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", 
+		"'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", 
+		"'>>>='", null, "'@'", "'...'"
+	};
+	private static final String[] _SYMBOLIC_NAMES = {
+		null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", 
+		"CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", 
+		"ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", 
+		"IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", 
+		"PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", 
+		"SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", 
+		"TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "FloatingPointLiteral", 
+		"BooleanLiteral", "CharacterLiteral", "StringLiteral", "NullLiteral", 
+		"LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", 
+		"DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", "COLON", "EQUAL", 
+		"LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", "SUB", "MUL", 
+		"DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", "ADD_ASSIGN", 
+		"SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", 
+		"MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", 
+		"AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT"
+	};
+	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
+
+	/**
+	 * @deprecated Use {@link #VOCABULARY} instead.
+	 */
+	@Deprecated
+	public static final String[] tokenNames;
+	static {
+		tokenNames = new String[_SYMBOLIC_NAMES.length];
+		for (int i = 0; i < tokenNames.length; i++) {
+			tokenNames[i] = VOCABULARY.getLiteralName(i);
+			if (tokenNames[i] == null) {
+				tokenNames[i] = VOCABULARY.getSymbolicName(i);
+			}
+
+			if (tokenNames[i] == null) {
+				tokenNames[i] = "<INVALID>";
+			}
+		}
+	}
+
+	@Override
+	@Deprecated
+	public String[] getTokenNames() {
+		return tokenNames;
+	}
+
+	@Override
+
+	public Vocabulary getVocabulary() {
+		return VOCABULARY;
+	}
+
+
+	public DroppingJavaLexer(CharStream input) {
+		super(input);
+		_interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
+	}
+
+	@Override
+	public String getGrammarFileName() { return "DroppingJava.g4"; }
+
+	@Override
+	public String[] getRuleNames() { return ruleNames; }
+
+	@Override
+	public String getSerializedATN() { return _serializedATN; }
+
+	@Override
+	public String[] getModeNames() { return modeNames; }
+
+	@Override
+	public ATN getATN() { return _ATN; }
+
+	@Override
+	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
+		switch (ruleIndex) {
+		case 146:
+			return JavaLetter_sempred((RuleContext)_localctx, predIndex);
+		case 147:
+			return JavaLetterOrDigit_sempred((RuleContext)_localctx, predIndex);
+		}
+		return true;
+	}
+	private boolean JavaLetter_sempred(RuleContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 0:
+			return Character.isJavaIdentifierStart(_input.LA(-1));
+		case 1:
+			return Character.isJavaIdentifierStart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1)));
+		}
+		return true;
+	}
+	private boolean JavaLetterOrDigit_sempred(RuleContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 2:
+			return Character.isJavaIdentifierPart(_input.LA(-1));
+		case 3:
+			return Character.isJavaIdentifierPart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1)));
+		}
+		return true;
+	}
+
+	public static final String _serializedATN =
+		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2m\u0448\b\1\4\2\t"+
+		"\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
+		"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
+		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
+		"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
+		"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
+		",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
+		"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
+		"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
+		"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
+		"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
+		"`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
+		"k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
+		"w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+
+		"\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+
+		"\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+
+		"\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+
+		"\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092"+
+		"\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097"+
+		"\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\3\2\3\2\3\2\3"+
+		"\2\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4"+
+		"\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3"+
+		"\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n"+
+		"\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f"+
+		"\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3"+
+		"\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\22\3"+
+		"\22\3\22\3\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\24\3"+
+		"\24\3\24\3\24\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\25\3\26\3"+
+		"\26\3\26\3\26\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3"+
+		"\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3"+
+		"\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34\3\34\3"+
+		"\34\3\34\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3"+
+		"\36\3\36\3\36\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3!\3!\3!"+
+		"\3!\3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3#\3#\3#\3"+
+		"#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3&\3&\3&\3&\3&\3&\3"+
+		"\'\3\'\3\'\3\'\3\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3)\3)\3)\3)\3)\3"+
+		")\3*\3*\3*\3*\3*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3,\3,\3"+
+		",\3,\3,\3-\3-\3-\3-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\3/\3"+
+		"/\3/\3/\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3\62\3\62\3\62\3"+
+		"\62\3\62\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3"+
+		"\64\3\64\5\64\u028d\n\64\3\65\3\65\5\65\u0291\n\65\3\66\3\66\5\66\u0295"+
+		"\n\66\3\67\3\67\5\67\u0299\n\67\38\38\58\u029d\n8\39\39\3:\3:\3:\5:\u02a4"+
+		"\n:\3:\3:\3:\5:\u02a9\n:\5:\u02ab\n:\3;\3;\5;\u02af\n;\3;\5;\u02b2\n;"+
+		"\3<\3<\5<\u02b6\n<\3=\3=\3>\6>\u02bb\n>\r>\16>\u02bc\3?\3?\5?\u02c1\n"+
+		"?\3@\6@\u02c4\n@\r@\16@\u02c5\3A\3A\3A\3A\3B\3B\5B\u02ce\nB\3B\5B\u02d1"+
+		"\nB\3C\3C\3D\6D\u02d6\nD\rD\16D\u02d7\3E\3E\5E\u02dc\nE\3F\3F\5F\u02e0"+
+		"\nF\3F\3F\3G\3G\5G\u02e6\nG\3G\5G\u02e9\nG\3H\3H\3I\6I\u02ee\nI\rI\16"+
+		"I\u02ef\3J\3J\5J\u02f4\nJ\3K\3K\3K\3K\3L\3L\5L\u02fc\nL\3L\5L\u02ff\n"+
+		"L\3M\3M\3N\6N\u0304\nN\rN\16N\u0305\3O\3O\5O\u030a\nO\3P\3P\5P\u030e\n"+
+		"P\3Q\3Q\3Q\5Q\u0313\nQ\3Q\5Q\u0316\nQ\3Q\5Q\u0319\nQ\3Q\3Q\3Q\5Q\u031e"+
+		"\nQ\3Q\5Q\u0321\nQ\3Q\3Q\3Q\5Q\u0326\nQ\3Q\3Q\3Q\5Q\u032b\nQ\3R\3R\3R"+
+		"\3S\3S\3T\5T\u0333\nT\3T\3T\3U\3U\3V\3V\3W\3W\3W\5W\u033e\nW\3X\3X\5X"+
+		"\u0342\nX\3X\3X\3X\5X\u0347\nX\3X\3X\5X\u034b\nX\3Y\3Y\3Y\3Z\3Z\3[\3["+
+		"\3[\3[\3[\3[\3[\3[\3[\5[\u035b\n[\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\5\\"+
+		"\u0365\n\\\3]\3]\3^\3^\5^\u036b\n^\3^\3^\3_\6_\u0370\n_\r_\16_\u0371\3"+
+		"`\3`\5`\u0376\n`\3a\3a\3a\3a\5a\u037c\na\3b\3b\3b\3b\3b\3b\3b\3b\3b\3"+
+		"b\3b\5b\u0389\nb\3c\3c\3d\3d\3d\3d\3d\3d\3d\3e\3e\3e\3e\3e\3f\3f\3g\3"+
+		"g\3h\3h\3i\3i\3j\3j\3k\3k\3l\3l\3m\3m\3n\3n\3o\3o\3p\3p\3q\3q\3r\3r\3"+
+		"s\3s\3t\3t\3u\3u\3v\3v\3v\3w\3w\3w\3x\3x\3x\3y\3y\3y\3z\3z\3z\3{\3{\3"+
+		"{\3|\3|\3|\3}\3}\3}\3~\3~\3\177\3\177\3\u0080\3\u0080\3\u0081\3\u0081"+
+		"\3\u0082\3\u0082\3\u0083\3\u0083\3\u0084\3\u0084\3\u0085\3\u0085\3\u0086"+
+		"\3\u0086\3\u0086\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088\3\u0088\3\u0089"+
+		"\3\u0089\3\u0089\3\u008a\3\u008a\3\u008a\3\u008b\3\u008b\3\u008b\3\u008c"+
+		"\3\u008c\3\u008c\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e\3\u008f"+
+		"\3\u008f\3\u008f\3\u0090\3\u0090\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091"+
+		"\3\u0091\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0093\3\u0093\7\u0093"+
+		"\u040e\n\u0093\f\u0093\16\u0093\u0411\13\u0093\3\u0094\3\u0094\3\u0094"+
+		"\3\u0094\3\u0094\3\u0094\5\u0094\u0419\n\u0094\3\u0095\3\u0095\3\u0095"+
+		"\3\u0095\3\u0095\3\u0095\5\u0095\u0421\n\u0095\3\u0096\3\u0096\3\u0097"+
+		"\3\u0097\3\u0097\3\u0097\3\u0098\6\u0098\u042a\n\u0098\r\u0098\16\u0098"+
+		"\u042b\3\u0098\3\u0098\3\u0099\3\u0099\3\u0099\3\u0099\7\u0099\u0434\n"+
+		"\u0099\f\u0099\16\u0099\u0437\13\u0099\3\u0099\3\u0099\3\u0099\3\u0099"+
+		"\3\u0099\3\u009a\3\u009a\3\u009a\3\u009a\7\u009a\u0442\n\u009a\f\u009a"+
+		"\16\u009a\u0445\13\u009a\3\u009a\3\u009a\3\u0435\2\u009b\3\3\5\4\7\5\t"+
+		"\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23"+
+		"%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34\67\359\36;\37= ?!A\"C#E$G"+
+		"%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63e\64g\65i\2k\2m\2o\2q\2s\2u\2w\2"+
+		"y\2{\2}\2\177\2\u0081\2\u0083\2\u0085\2\u0087\2\u0089\2\u008b\2\u008d"+
+		"\2\u008f\2\u0091\2\u0093\2\u0095\2\u0097\2\u0099\2\u009b\2\u009d\2\u009f"+
+		"\66\u00a1\2\u00a3\2\u00a5\2\u00a7\2\u00a9\2\u00ab\2\u00ad\2\u00af\2\u00b1"+
+		"\2\u00b3\2\u00b5\67\u00b78\u00b9\2\u00bb9\u00bd\2\u00bf\2\u00c1\2\u00c3"+
+		"\2\u00c5\2\u00c7\2\u00c9:\u00cb;\u00cd<\u00cf=\u00d1>\u00d3?\u00d5@\u00d7"+
+		"A\u00d9B\u00dbC\u00ddD\u00dfE\u00e1F\u00e3G\u00e5H\u00e7I\u00e9J\u00eb"+
+		"K\u00edL\u00efM\u00f1N\u00f3O\u00f5P\u00f7Q\u00f9R\u00fbS\u00fdT\u00ff"+
+		"U\u0101V\u0103W\u0105X\u0107Y\u0109Z\u010b[\u010d\\\u010f]\u0111^\u0113"+
+		"_\u0115`\u0117a\u0119b\u011bc\u011dd\u011fe\u0121f\u0123g\u0125h\u0127"+
+		"\2\u0129\2\u012bi\u012dj\u012fk\u0131l\u0133m\3\2\30\4\2NNnn\3\2\63;\4"+
+		"\2ZZzz\5\2\62;CHch\3\2\629\4\2DDdd\3\2\62\63\4\2GGgg\4\2--//\6\2FFHHf"+
+		"fhh\4\2RRrr\4\2))^^\4\2$$^^\n\2$$))^^ddhhppttvv\3\2\62\65\6\2&&C\\aac"+
+		"|\4\2\2\u0081\ud802\udc01\3\2\ud802\udc01\3\2\udc02\ue001\7\2&&\62;C\\"+
+		"aac|\5\2\13\f\16\17\"\"\4\2\f\f\17\17\u0456\2\3\3\2\2\2\2\5\3\2\2\2\2"+
+		"\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2"+
+		"\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2"+
+		"\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2"+
+		"\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2"+
+		"\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2"+
+		"\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2"+
+		"M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3"+
+		"\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2e\3\2\2"+
+		"\2\2g\3\2\2\2\2\u009f\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7\3\2\2\2\2\u00bb"+
+		"\3\2\2\2\2\u00c9\3\2\2\2\2\u00cb\3\2\2\2\2\u00cd\3\2\2\2\2\u00cf\3\2\2"+
+		"\2\2\u00d1\3\2\2\2\2\u00d3\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7\3\2\2\2\2\u00d9"+
+		"\3\2\2\2\2\u00db\3\2\2\2\2\u00dd\3\2\2\2\2\u00df\3\2\2\2\2\u00e1\3\2\2"+
+		"\2\2\u00e3\3\2\2\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2\2\2\u00e9\3\2\2\2\2\u00eb"+
+		"\3\2\2\2\2\u00ed\3\2\2\2\2\u00ef\3\2\2\2\2\u00f1\3\2\2\2\2\u00f3\3\2\2"+
+		"\2\2\u00f5\3\2\2\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd"+
+		"\3\2\2\2\2\u00ff\3\2\2\2\2\u0101\3\2\2\2\2\u0103\3\2\2\2\2\u0105\3\2\2"+
+		"\2\2\u0107\3\2\2\2\2\u0109\3\2\2\2\2\u010b\3\2\2\2\2\u010d\3\2\2\2\2\u010f"+
+		"\3\2\2\2\2\u0111\3\2\2\2\2\u0113\3\2\2\2\2\u0115\3\2\2\2\2\u0117\3\2\2"+
+		"\2\2\u0119\3\2\2\2\2\u011b\3\2\2\2\2\u011d\3\2\2\2\2\u011f\3\2\2\2\2\u0121"+
+		"\3\2\2\2\2\u0123\3\2\2\2\2\u0125\3\2\2\2\2\u012b\3\2\2\2\2\u012d\3\2\2"+
+		"\2\2\u012f\3\2\2\2\2\u0131\3\2\2\2\2\u0133\3\2\2\2\3\u0135\3\2\2\2\5\u013e"+
+		"\3\2\2\2\7\u0145\3\2\2\2\t\u014d\3\2\2\2\13\u0153\3\2\2\2\r\u0158\3\2"+
+		"\2\2\17\u015d\3\2\2\2\21\u0163\3\2\2\2\23\u0168\3\2\2\2\25\u016e\3\2\2"+
+		"\2\27\u0174\3\2\2\2\31\u017d\3\2\2\2\33\u0185\3\2\2\2\35\u0188\3\2\2\2"+
+		"\37\u018f\3\2\2\2!\u0194\3\2\2\2#\u0199\3\2\2\2%\u01a1\3\2\2\2\'\u01a7"+
+		"\3\2\2\2)\u01af\3\2\2\2+\u01b5\3\2\2\2-\u01b9\3\2\2\2/\u01bc\3\2\2\2\61"+
+		"\u01c1\3\2\2\2\63\u01cc\3\2\2\2\65\u01d3\3\2\2\2\67\u01de\3\2\2\29\u01e2"+
+		"\3\2\2\2;\u01ec\3\2\2\2=\u01f1\3\2\2\2?\u01f8\3\2\2\2A\u01fc\3\2\2\2C"+
+		"\u0204\3\2\2\2E\u020c\3\2\2\2G\u0216\3\2\2\2I\u021d\3\2\2\2K\u0224\3\2"+
+		"\2\2M\u022a\3\2\2\2O\u0231\3\2\2\2Q\u023a\3\2\2\2S\u0240\3\2\2\2U\u0247"+
+		"\3\2\2\2W\u0254\3\2\2\2Y\u0259\3\2\2\2[\u025f\3\2\2\2]\u0266\3\2\2\2_"+
+		"\u0270\3\2\2\2a\u0274\3\2\2\2c\u0279\3\2\2\2e\u0282\3\2\2\2g\u028c\3\2"+
+		"\2\2i\u028e\3\2\2\2k\u0292\3\2\2\2m\u0296\3\2\2\2o\u029a\3\2\2\2q\u029e"+
+		"\3\2\2\2s\u02aa\3\2\2\2u\u02ac\3\2\2\2w\u02b5\3\2\2\2y\u02b7\3\2\2\2{"+
+		"\u02ba\3\2\2\2}\u02c0\3\2\2\2\177\u02c3\3\2\2\2\u0081\u02c7\3\2\2\2\u0083"+
+		"\u02cb\3\2\2\2\u0085\u02d2\3\2\2\2\u0087\u02d5\3\2\2\2\u0089\u02db\3\2"+
+		"\2\2\u008b\u02dd\3\2\2\2\u008d\u02e3\3\2\2\2\u008f\u02ea\3\2\2\2\u0091"+
+		"\u02ed\3\2\2\2\u0093\u02f3\3\2\2\2\u0095\u02f5\3\2\2\2\u0097\u02f9\3\2"+
+		"\2\2\u0099\u0300\3\2\2\2\u009b\u0303\3\2\2\2\u009d\u0309\3\2\2\2\u009f"+
+		"\u030d\3\2\2\2\u00a1\u032a\3\2\2\2\u00a3\u032c\3\2\2\2\u00a5\u032f\3\2"+
+		"\2\2\u00a7\u0332\3\2\2\2\u00a9\u0336\3\2\2\2\u00ab\u0338\3\2\2\2\u00ad"+
+		"\u033a\3\2\2\2\u00af\u034a\3\2\2\2\u00b1\u034c\3\2\2\2\u00b3\u034f\3\2"+
+		"\2\2\u00b5\u035a\3\2\2\2\u00b7\u0364\3\2\2\2\u00b9\u0366\3\2\2\2\u00bb"+
+		"\u0368\3\2\2\2\u00bd\u036f\3\2\2\2\u00bf\u0375\3\2\2\2\u00c1\u037b\3\2"+
+		"\2\2\u00c3\u0388\3\2\2\2\u00c5\u038a\3\2\2\2\u00c7\u038c\3\2\2\2\u00c9"+
+		"\u0393\3\2\2\2\u00cb\u0398\3\2\2\2\u00cd\u039a\3\2\2\2\u00cf\u039c\3\2"+
+		"\2\2\u00d1\u039e\3\2\2\2\u00d3\u03a0\3\2\2\2\u00d5\u03a2\3\2\2\2\u00d7"+
+		"\u03a4\3\2\2\2\u00d9\u03a6\3\2\2\2\u00db\u03a8\3\2\2\2\u00dd\u03aa\3\2"+
+		"\2\2\u00df\u03ac\3\2\2\2\u00e1\u03ae\3\2\2\2\u00e3\u03b0\3\2\2\2\u00e5"+
+		"\u03b2\3\2\2\2\u00e7\u03b4\3\2\2\2\u00e9\u03b6\3\2\2\2\u00eb\u03b8\3\2"+
+		"\2\2\u00ed\u03bb\3\2\2\2\u00ef\u03be\3\2\2\2\u00f1\u03c1\3\2\2\2\u00f3"+
+		"\u03c4\3\2\2\2\u00f5\u03c7\3\2\2\2\u00f7\u03ca\3\2\2\2\u00f9\u03cd\3\2"+
+		"\2\2\u00fb\u03d0\3\2\2\2\u00fd\u03d2\3\2\2\2\u00ff\u03d4\3\2\2\2\u0101"+
+		"\u03d6\3\2\2\2\u0103\u03d8\3\2\2\2\u0105\u03da\3\2\2\2\u0107\u03dc\3\2"+
+		"\2\2\u0109\u03de\3\2\2\2\u010b\u03e0\3\2\2\2\u010d\u03e3\3\2\2\2\u010f"+
+		"\u03e6\3\2\2\2\u0111\u03e9\3\2\2\2\u0113\u03ec\3\2\2\2\u0115\u03ef\3\2"+
+		"\2\2\u0117\u03f2\3\2\2\2\u0119\u03f5\3\2\2\2\u011b\u03f8\3\2\2\2\u011d"+
+		"\u03fb\3\2\2\2\u011f\u03fe\3\2\2\2\u0121\u0402\3\2\2\2\u0123\u0406\3\2"+
+		"\2\2\u0125\u040b\3\2\2\2\u0127\u0418\3\2\2\2\u0129\u0420\3\2\2\2\u012b"+
+		"\u0422\3\2\2\2\u012d\u0424\3\2\2\2\u012f\u0429\3\2\2\2\u0131\u042f\3\2"+
+		"\2\2\u0133\u043d\3\2\2\2\u0135\u0136\7c\2\2\u0136\u0137\7d\2\2\u0137\u0138"+
+		"\7u\2\2\u0138\u0139\7v\2\2\u0139\u013a\7t\2\2\u013a\u013b\7c\2\2\u013b"+
+		"\u013c\7e\2\2\u013c\u013d\7v\2\2\u013d\4\3\2\2\2\u013e\u013f\7c\2\2\u013f"+
+		"\u0140\7u\2\2\u0140\u0141\7u\2\2\u0141\u0142\7g\2\2\u0142\u0143\7t\2\2"+
+		"\u0143\u0144\7v\2\2\u0144\6\3\2\2\2\u0145\u0146\7d\2\2\u0146\u0147\7q"+
+		"\2\2\u0147\u0148\7q\2\2\u0148\u0149\7n\2\2\u0149\u014a\7g\2\2\u014a\u014b"+
+		"\7c\2\2\u014b\u014c\7p\2\2\u014c\b\3\2\2\2\u014d\u014e\7d\2\2\u014e\u014f"+
+		"\7t\2\2\u014f\u0150\7g\2\2\u0150\u0151\7c\2\2\u0151\u0152\7m\2\2\u0152"+
+		"\n\3\2\2\2\u0153\u0154\7d\2\2\u0154\u0155\7{\2\2\u0155\u0156\7v\2\2\u0156"+
+		"\u0157\7g\2\2\u0157\f\3\2\2\2\u0158\u0159\7e\2\2\u0159\u015a\7c\2\2\u015a"+
+		"\u015b\7u\2\2\u015b\u015c\7g\2\2\u015c\16\3\2\2\2\u015d\u015e\7e\2\2\u015e"+
+		"\u015f\7c\2\2\u015f\u0160\7v\2\2\u0160\u0161\7e\2\2\u0161\u0162\7j\2\2"+
+		"\u0162\20\3\2\2\2\u0163\u0164\7e\2\2\u0164\u0165\7j\2\2\u0165\u0166\7"+
+		"c\2\2\u0166\u0167\7t\2\2\u0167\22\3\2\2\2\u0168\u0169\7e\2\2\u0169\u016a"+
+		"\7n\2\2\u016a\u016b\7c\2\2\u016b\u016c\7u\2\2\u016c\u016d\7u\2\2\u016d"+
+		"\24\3\2\2\2\u016e\u016f\7e\2\2\u016f\u0170\7q\2\2\u0170\u0171\7p\2\2\u0171"+
+		"\u0172\7u\2\2\u0172\u0173\7v\2\2\u0173\26\3\2\2\2\u0174\u0175\7e\2\2\u0175"+
+		"\u0176\7q\2\2\u0176\u0177\7p\2\2\u0177\u0178\7v\2\2\u0178\u0179\7k\2\2"+
+		"\u0179\u017a\7p\2\2\u017a\u017b\7w\2\2\u017b\u017c\7g\2\2\u017c\30\3\2"+
+		"\2\2\u017d\u017e\7f\2\2\u017e\u017f\7g\2\2\u017f\u0180\7h\2\2\u0180\u0181"+
+		"\7c\2\2\u0181\u0182\7w\2\2\u0182\u0183\7n\2\2\u0183\u0184\7v\2\2\u0184"+
+		"\32\3\2\2\2\u0185\u0186\7f\2\2\u0186\u0187\7q\2\2\u0187\34\3\2\2\2\u0188"+
+		"\u0189\7f\2\2\u0189\u018a\7q\2\2\u018a\u018b\7w\2\2\u018b\u018c\7d\2\2"+
+		"\u018c\u018d\7n\2\2\u018d\u018e\7g\2\2\u018e\36\3\2\2\2\u018f\u0190\7"+
+		"g\2\2\u0190\u0191\7n\2\2\u0191\u0192\7u\2\2\u0192\u0193\7g\2\2\u0193 "+
+		"\3\2\2\2\u0194\u0195\7g\2\2\u0195\u0196\7p\2\2\u0196\u0197\7w\2\2\u0197"+
+		"\u0198\7o\2\2\u0198\"\3\2\2\2\u0199\u019a\7g\2\2\u019a\u019b\7z\2\2\u019b"+
+		"\u019c\7v\2\2\u019c\u019d\7g\2\2\u019d\u019e\7p\2\2\u019e\u019f\7f\2\2"+
+		"\u019f\u01a0\7u\2\2\u01a0$\3\2\2\2\u01a1\u01a2\7h\2\2\u01a2\u01a3\7k\2"+
+		"\2\u01a3\u01a4\7p\2\2\u01a4\u01a5\7c\2\2\u01a5\u01a6\7n\2\2\u01a6&\3\2"+
+		"\2\2\u01a7\u01a8\7h\2\2\u01a8\u01a9\7k\2\2\u01a9\u01aa\7p\2\2\u01aa\u01ab"+
+		"\7c\2\2\u01ab\u01ac\7n\2\2\u01ac\u01ad\7n\2\2\u01ad\u01ae\7{\2\2\u01ae"+
+		"(\3\2\2\2\u01af\u01b0\7h\2\2\u01b0\u01b1\7n\2\2\u01b1\u01b2\7q\2\2\u01b2"+
+		"\u01b3\7c\2\2\u01b3\u01b4\7v\2\2\u01b4*\3\2\2\2\u01b5\u01b6\7h\2\2\u01b6"+
+		"\u01b7\7q\2\2\u01b7\u01b8\7t\2\2\u01b8,\3\2\2\2\u01b9\u01ba\7k\2\2\u01ba"+
+		"\u01bb\7h\2\2\u01bb.\3\2\2\2\u01bc\u01bd\7i\2\2\u01bd\u01be\7q\2\2\u01be"+
+		"\u01bf\7v\2\2\u01bf\u01c0\7q\2\2\u01c0\60\3\2\2\2\u01c1\u01c2\7k\2\2\u01c2"+
+		"\u01c3\7o\2\2\u01c3\u01c4\7r\2\2\u01c4\u01c5\7n\2\2\u01c5\u01c6\7g\2\2"+
+		"\u01c6\u01c7\7o\2\2\u01c7\u01c8\7g\2\2\u01c8\u01c9\7p\2\2\u01c9\u01ca"+
+		"\7v\2\2\u01ca\u01cb\7u\2\2\u01cb\62\3\2\2\2\u01cc\u01cd\7k\2\2\u01cd\u01ce"+
+		"\7o\2\2\u01ce\u01cf\7r\2\2\u01cf\u01d0\7q\2\2\u01d0\u01d1\7t\2\2\u01d1"+
+		"\u01d2\7v\2\2\u01d2\64\3\2\2\2\u01d3\u01d4\7k\2\2\u01d4\u01d5\7p\2\2\u01d5"+
+		"\u01d6\7u\2\2\u01d6\u01d7\7v\2\2\u01d7\u01d8\7c\2\2\u01d8\u01d9\7p\2\2"+
+		"\u01d9\u01da\7e\2\2\u01da\u01db\7g\2\2\u01db\u01dc\7q\2\2\u01dc\u01dd"+
+		"\7h\2\2\u01dd\66\3\2\2\2\u01de\u01df\7k\2\2\u01df\u01e0\7p\2\2\u01e0\u01e1"+
+		"\7v\2\2\u01e18\3\2\2\2\u01e2\u01e3\7k\2\2\u01e3\u01e4\7p\2\2\u01e4\u01e5"+
+		"\7v\2\2\u01e5\u01e6\7g\2\2\u01e6\u01e7\7t\2\2\u01e7\u01e8\7h\2\2\u01e8"+
+		"\u01e9\7c\2\2\u01e9\u01ea\7e\2\2\u01ea\u01eb\7g\2\2\u01eb:\3\2\2\2\u01ec"+
+		"\u01ed\7n\2\2\u01ed\u01ee\7q\2\2\u01ee\u01ef\7p\2\2\u01ef\u01f0\7i\2\2"+
+		"\u01f0<\3\2\2\2\u01f1\u01f2\7p\2\2\u01f2\u01f3\7c\2\2\u01f3\u01f4\7v\2"+
+		"\2\u01f4\u01f5\7k\2\2\u01f5\u01f6\7x\2\2\u01f6\u01f7\7g\2\2\u01f7>\3\2"+
+		"\2\2\u01f8\u01f9\7p\2\2\u01f9\u01fa\7g\2\2\u01fa\u01fb\7y\2\2\u01fb@\3"+
+		"\2\2\2\u01fc\u01fd\7r\2\2\u01fd\u01fe\7c\2\2\u01fe\u01ff\7e\2\2\u01ff"+
+		"\u0200\7m\2\2\u0200\u0201\7c\2\2\u0201\u0202\7i\2\2\u0202\u0203\7g\2\2"+
+		"\u0203B\3\2\2\2\u0204\u0205\7r\2\2\u0205\u0206\7t\2\2\u0206\u0207\7k\2"+
+		"\2\u0207\u0208\7x\2\2\u0208\u0209\7c\2\2\u0209\u020a\7v\2\2\u020a\u020b"+
+		"\7g\2\2\u020bD\3\2\2\2\u020c\u020d\7r\2\2\u020d\u020e\7t\2\2\u020e\u020f"+
+		"\7q\2\2\u020f\u0210\7v\2\2\u0210\u0211\7g\2\2\u0211\u0212\7e\2\2\u0212"+
+		"\u0213\7v\2\2\u0213\u0214\7g\2\2\u0214\u0215\7f\2\2\u0215F\3\2\2\2\u0216"+
+		"\u0217\7r\2\2\u0217\u0218\7w\2\2\u0218\u0219\7d\2\2\u0219\u021a\7n\2\2"+
+		"\u021a\u021b\7k\2\2\u021b\u021c\7e\2\2\u021cH\3\2\2\2\u021d\u021e\7t\2"+
+		"\2\u021e\u021f\7g\2\2\u021f\u0220\7v\2\2\u0220\u0221\7w\2\2\u0221\u0222"+
+		"\7t\2\2\u0222\u0223\7p\2\2\u0223J\3\2\2\2\u0224\u0225\7u\2\2\u0225\u0226"+
+		"\7j\2\2\u0226\u0227\7q\2\2\u0227\u0228\7t\2\2\u0228\u0229\7v\2\2\u0229"+
+		"L\3\2\2\2\u022a\u022b\7u\2\2\u022b\u022c\7v\2\2\u022c\u022d\7c\2\2\u022d"+
+		"\u022e\7v\2\2\u022e\u022f\7k\2\2\u022f\u0230\7e\2\2\u0230N\3\2\2\2\u0231"+
+		"\u0232\7u\2\2\u0232\u0233\7v\2\2\u0233\u0234\7t\2\2\u0234\u0235\7k\2\2"+
+		"\u0235\u0236\7e\2\2\u0236\u0237\7v\2\2\u0237\u0238\7h\2\2\u0238\u0239"+
+		"\7r\2\2\u0239P\3\2\2\2\u023a\u023b\7u\2\2\u023b\u023c\7w\2\2\u023c\u023d"+
+		"\7r\2\2\u023d\u023e\7g\2\2\u023e\u023f\7t\2\2\u023fR\3\2\2\2\u0240\u0241"+
+		"\7u\2\2\u0241\u0242\7y\2\2\u0242\u0243\7k\2\2\u0243\u0244\7v\2\2\u0244"+
+		"\u0245\7e\2\2\u0245\u0246\7j\2\2\u0246T\3\2\2\2\u0247\u0248\7u\2\2\u0248"+
+		"\u0249\7{\2\2\u0249\u024a\7p\2\2\u024a\u024b\7e\2\2\u024b\u024c\7j\2\2"+
+		"\u024c\u024d\7t\2\2\u024d\u024e\7q\2\2\u024e\u024f\7p\2\2\u024f\u0250"+
+		"\7k\2\2\u0250\u0251\7|\2\2\u0251\u0252\7g\2\2\u0252\u0253\7f\2\2\u0253"+
+		"V\3\2\2\2\u0254\u0255\7v\2\2\u0255\u0256\7j\2\2\u0256\u0257\7k\2\2\u0257"+
+		"\u0258\7u\2\2\u0258X\3\2\2\2\u0259\u025a\7v\2\2\u025a\u025b\7j\2\2\u025b"+
+		"\u025c\7t\2\2\u025c\u025d\7q\2\2\u025d\u025e\7y\2\2\u025eZ\3\2\2\2\u025f"+
+		"\u0260\7v\2\2\u0260\u0261\7j\2\2\u0261\u0262\7t\2\2\u0262\u0263\7q\2\2"+
+		"\u0263\u0264\7y\2\2\u0264\u0265\7u\2\2\u0265\\\3\2\2\2\u0266\u0267\7v"+
+		"\2\2\u0267\u0268\7t\2\2\u0268\u0269\7c\2\2\u0269\u026a\7p\2\2\u026a\u026b"+
+		"\7u\2\2\u026b\u026c\7k\2\2\u026c\u026d\7g\2\2\u026d\u026e\7p\2\2\u026e"+
+		"\u026f\7v\2\2\u026f^\3\2\2\2\u0270\u0271\7v\2\2\u0271\u0272\7t\2\2\u0272"+
+		"\u0273\7{\2\2\u0273`\3\2\2\2\u0274\u0275\7x\2\2\u0275\u0276\7q\2\2\u0276"+
+		"\u0277\7k\2\2\u0277\u0278\7f\2\2\u0278b\3\2\2\2\u0279\u027a\7x\2\2\u027a"+
+		"\u027b\7q\2\2\u027b\u027c\7n\2\2\u027c\u027d\7c\2\2\u027d\u027e\7v\2\2"+
+		"\u027e\u027f\7k\2\2\u027f\u0280\7n\2\2\u0280\u0281\7g\2\2\u0281d\3\2\2"+
+		"\2\u0282\u0283\7y\2\2\u0283\u0284\7j\2\2\u0284\u0285\7k\2\2\u0285\u0286"+
+		"\7n\2\2\u0286\u0287\7g\2\2\u0287f\3\2\2\2\u0288\u028d\5i\65\2\u0289\u028d"+
+		"\5k\66\2\u028a\u028d\5m\67\2\u028b\u028d\5o8\2\u028c\u0288\3\2\2\2\u028c"+
+		"\u0289\3\2\2\2\u028c\u028a\3\2\2\2\u028c\u028b\3\2\2\2\u028dh\3\2\2\2"+
+		"\u028e\u0290\5s:\2\u028f\u0291\5q9\2\u0290\u028f\3\2\2\2\u0290\u0291\3"+
+		"\2\2\2\u0291j\3\2\2\2\u0292\u0294\5\u0081A\2\u0293\u0295\5q9\2\u0294\u0293"+
+		"\3\2\2\2\u0294\u0295\3\2\2\2\u0295l\3\2\2\2\u0296\u0298\5\u008bF\2\u0297"+
+		"\u0299\5q9\2\u0298\u0297\3\2\2\2\u0298\u0299\3\2\2\2\u0299n\3\2\2\2\u029a"+
+		"\u029c\5\u0095K\2\u029b\u029d\5q9\2\u029c\u029b\3\2\2\2\u029c\u029d\3"+
+		"\2\2\2\u029dp\3\2\2\2\u029e\u029f\t\2\2\2\u029fr\3\2\2\2\u02a0\u02ab\7"+
+		"\62\2\2\u02a1\u02a8\5y=\2\u02a2\u02a4\5u;\2\u02a3\u02a2\3\2\2\2\u02a3"+
+		"\u02a4\3\2\2\2\u02a4\u02a9\3\2\2\2\u02a5\u02a6\5\177@\2\u02a6\u02a7\5"+
+		"u;\2\u02a7\u02a9\3\2\2\2\u02a8\u02a3\3\2\2\2\u02a8\u02a5\3\2\2\2\u02a9"+
+		"\u02ab\3\2\2\2\u02aa\u02a0\3\2\2\2\u02aa\u02a1\3\2\2\2\u02abt\3\2\2\2"+
+		"\u02ac\u02b1\5w<\2\u02ad\u02af\5{>\2\u02ae\u02ad\3\2\2\2\u02ae\u02af\3"+
+		"\2\2\2\u02af\u02b0\3\2\2\2\u02b0\u02b2\5w<\2\u02b1\u02ae\3\2\2\2\u02b1"+
+		"\u02b2\3\2\2\2\u02b2v\3\2\2\2\u02b3\u02b6\7\62\2\2\u02b4\u02b6\5y=\2\u02b5"+
+		"\u02b3\3\2\2\2\u02b5\u02b4\3\2\2\2\u02b6x\3\2\2\2\u02b7\u02b8\t\3\2\2"+
+		"\u02b8z\3\2\2\2\u02b9\u02bb\5}?\2\u02ba\u02b9\3\2\2\2\u02bb\u02bc\3\2"+
+		"\2\2\u02bc\u02ba\3\2\2\2\u02bc\u02bd\3\2\2\2\u02bd|\3\2\2\2\u02be\u02c1"+
+		"\5w<\2\u02bf\u02c1\7a\2\2\u02c0\u02be\3\2\2\2\u02c0\u02bf\3\2\2\2\u02c1"+
+		"~\3\2\2\2\u02c2\u02c4\7a\2\2\u02c3\u02c2\3\2\2\2\u02c4\u02c5\3\2\2\2\u02c5"+
+		"\u02c3\3\2\2\2\u02c5\u02c6\3\2\2\2\u02c6\u0080\3\2\2\2\u02c7\u02c8\7\62"+
+		"\2\2\u02c8\u02c9\t\4\2\2\u02c9\u02ca\5\u0083B\2\u02ca\u0082\3\2\2\2\u02cb"+
+		"\u02d0\5\u0085C\2\u02cc\u02ce\5\u0087D\2\u02cd\u02cc\3\2\2\2\u02cd\u02ce"+
+		"\3\2\2\2\u02ce\u02cf\3\2\2\2\u02cf\u02d1\5\u0085C\2\u02d0\u02cd\3\2\2"+
+		"\2\u02d0\u02d1\3\2\2\2\u02d1\u0084\3\2\2\2\u02d2\u02d3\t\5\2\2\u02d3\u0086"+
+		"\3\2\2\2\u02d4\u02d6\5\u0089E\2\u02d5\u02d4\3\2\2\2\u02d6\u02d7\3\2\2"+
+		"\2\u02d7\u02d5\3\2\2\2\u02d7\u02d8\3\2\2\2\u02d8\u0088\3\2\2\2\u02d9\u02dc"+
+		"\5\u0085C\2\u02da\u02dc\7a\2\2\u02db\u02d9\3\2\2\2\u02db\u02da\3\2\2\2"+
+		"\u02dc\u008a\3\2\2\2\u02dd\u02df\7\62\2\2\u02de\u02e0\5\177@\2\u02df\u02de"+
+		"\3\2\2\2\u02df\u02e0\3\2\2\2\u02e0\u02e1\3\2\2\2\u02e1\u02e2\5\u008dG"+
+		"\2\u02e2\u008c\3\2\2\2\u02e3\u02e8\5\u008fH\2\u02e4\u02e6\5\u0091I\2\u02e5"+
+		"\u02e4\3\2\2\2\u02e5\u02e6\3\2\2\2\u02e6\u02e7\3\2\2\2\u02e7\u02e9\5\u008f"+
+		"H\2\u02e8\u02e5\3\2\2\2\u02e8\u02e9\3\2\2\2\u02e9\u008e\3\2\2\2\u02ea"+
+		"\u02eb\t\6\2\2\u02eb\u0090\3\2\2\2\u02ec\u02ee\5\u0093J\2\u02ed\u02ec"+
+		"\3\2\2\2\u02ee\u02ef\3\2\2\2\u02ef\u02ed\3\2\2\2\u02ef\u02f0\3\2\2\2\u02f0"+
+		"\u0092\3\2\2\2\u02f1\u02f4\5\u008fH\2\u02f2\u02f4\7a\2\2\u02f3\u02f1\3"+
+		"\2\2\2\u02f3\u02f2\3\2\2\2\u02f4\u0094\3\2\2\2\u02f5\u02f6\7\62\2\2\u02f6"+
+		"\u02f7\t\7\2\2\u02f7\u02f8\5\u0097L\2\u02f8\u0096\3\2\2\2\u02f9\u02fe"+
+		"\5\u0099M\2\u02fa\u02fc\5\u009bN\2\u02fb\u02fa\3\2\2\2\u02fb\u02fc\3\2"+
+		"\2\2\u02fc\u02fd\3\2\2\2\u02fd\u02ff\5\u0099M\2\u02fe\u02fb\3\2\2\2\u02fe"+
+		"\u02ff\3\2\2\2\u02ff\u0098\3\2\2\2\u0300\u0301\t\b\2\2\u0301\u009a\3\2"+
+		"\2\2\u0302\u0304\5\u009dO\2\u0303\u0302\3\2\2\2\u0304\u0305\3\2\2\2\u0305"+
+		"\u0303\3\2\2\2\u0305\u0306\3\2\2\2\u0306\u009c\3\2\2\2\u0307\u030a\5\u0099"+
+		"M\2\u0308\u030a\7a\2\2\u0309\u0307\3\2\2\2\u0309\u0308\3\2\2\2\u030a\u009e"+
+		"\3\2\2\2\u030b\u030e\5\u00a1Q\2\u030c\u030e\5\u00adW\2\u030d\u030b\3\2"+
+		"\2\2\u030d\u030c\3\2\2\2\u030e\u00a0\3\2\2\2\u030f\u0310\5u;\2\u0310\u0312"+
+		"\7\60\2\2\u0311\u0313\5u;\2\u0312\u0311\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+
+		"\u0315\3\2\2\2\u0314\u0316\5\u00a3R\2\u0315\u0314\3\2\2\2\u0315\u0316"+
+		"\3\2\2\2\u0316\u0318\3\2\2\2\u0317\u0319\5\u00abV\2\u0318\u0317\3\2\2"+
+		"\2\u0318\u0319\3\2\2\2\u0319\u032b\3\2\2\2\u031a\u031b\7\60\2\2\u031b"+
+		"\u031d\5u;\2\u031c\u031e\5\u00a3R\2\u031d\u031c\3\2\2\2\u031d\u031e\3"+
+		"\2\2\2\u031e\u0320\3\2\2\2\u031f\u0321\5\u00abV\2\u0320\u031f\3\2\2\2"+
+		"\u0320\u0321\3\2\2\2\u0321\u032b\3\2\2\2\u0322\u0323\5u;\2\u0323\u0325"+
+		"\5\u00a3R\2\u0324\u0326\5\u00abV\2\u0325\u0324\3\2\2\2\u0325\u0326\3\2"+
+		"\2\2\u0326\u032b\3\2\2\2\u0327\u0328\5u;\2\u0328\u0329\5\u00abV\2\u0329"+
+		"\u032b\3\2\2\2\u032a\u030f\3\2\2\2\u032a\u031a\3\2\2\2\u032a\u0322\3\2"+
+		"\2\2\u032a\u0327\3\2\2\2\u032b\u00a2\3\2\2\2\u032c\u032d\5\u00a5S\2\u032d"+
+		"\u032e\5\u00a7T\2\u032e\u00a4\3\2\2\2\u032f\u0330\t\t\2\2\u0330\u00a6"+
+		"\3\2\2\2\u0331\u0333\5\u00a9U\2\u0332\u0331\3\2\2\2\u0332\u0333\3\2\2"+
+		"\2\u0333\u0334\3\2\2\2\u0334\u0335\5u;\2\u0335\u00a8\3\2\2\2\u0336\u0337"+
+		"\t\n\2\2\u0337\u00aa\3\2\2\2\u0338\u0339\t\13\2\2\u0339\u00ac\3\2\2\2"+
+		"\u033a\u033b\5\u00afX\2\u033b\u033d\5\u00b1Y\2\u033c\u033e\5\u00abV\2"+
+		"\u033d\u033c\3\2\2\2\u033d\u033e\3\2\2\2\u033e\u00ae\3\2\2\2\u033f\u0341"+
+		"\5\u0081A\2\u0340\u0342\7\60\2\2\u0341\u0340\3\2\2\2\u0341\u0342\3\2\2"+
+		"\2\u0342\u034b\3\2\2\2\u0343\u0344\7\62\2\2\u0344\u0346\t\4\2\2\u0345"+
+		"\u0347\5\u0083B\2\u0346\u0345\3\2\2\2\u0346\u0347\3\2\2\2\u0347\u0348"+
+		"\3\2\2\2\u0348\u0349\7\60\2\2\u0349\u034b\5\u0083B\2\u034a\u033f\3\2\2"+
+		"\2\u034a\u0343\3\2\2\2\u034b\u00b0\3\2\2\2\u034c\u034d\5\u00b3Z\2\u034d"+
+		"\u034e\5\u00a7T\2\u034e\u00b2\3\2\2\2\u034f\u0350\t\f\2\2\u0350\u00b4"+
+		"\3\2\2\2\u0351\u0352\7v\2\2\u0352\u0353\7t\2\2\u0353\u0354\7w\2\2\u0354"+
+		"\u035b\7g\2\2\u0355\u0356\7h\2\2\u0356\u0357\7c\2\2\u0357\u0358\7n\2\2"+
+		"\u0358\u0359\7u\2\2\u0359\u035b\7g\2\2\u035a\u0351\3\2\2\2\u035a\u0355"+
+		"\3\2\2\2\u035b\u00b6\3\2\2\2\u035c\u035d\7)\2\2\u035d\u035e\5\u00b9]\2"+
+		"\u035e\u035f\7)\2\2\u035f\u0365\3\2\2\2\u0360\u0361\7)\2\2\u0361\u0362"+
+		"\5\u00c1a\2\u0362\u0363\7)\2\2\u0363\u0365\3\2\2\2\u0364\u035c\3\2\2\2"+
+		"\u0364\u0360\3\2\2\2\u0365\u00b8\3\2\2\2\u0366\u0367\n\r\2\2\u0367\u00ba"+
+		"\3\2\2\2\u0368\u036a\7$\2\2\u0369\u036b\5\u00bd_\2\u036a\u0369\3\2\2\2"+
+		"\u036a\u036b\3\2\2\2\u036b\u036c\3\2\2\2\u036c\u036d\7$\2\2\u036d\u00bc"+
+		"\3\2\2\2\u036e\u0370\5\u00bf`\2\u036f\u036e\3\2\2\2\u0370\u0371\3\2\2"+
+		"\2\u0371\u036f\3\2\2\2\u0371\u0372\3\2\2\2\u0372\u00be\3\2\2\2\u0373\u0376"+
+		"\n\16\2\2\u0374\u0376\5\u00c1a\2\u0375\u0373\3\2\2\2\u0375\u0374\3\2\2"+
+		"\2\u0376\u00c0\3\2\2\2\u0377\u0378\7^\2\2\u0378\u037c\t\17\2\2\u0379\u037c"+
+		"\5\u00c3b\2\u037a\u037c\5\u00c7d\2\u037b\u0377\3\2\2\2\u037b\u0379\3\2"+
+		"\2\2\u037b\u037a\3\2\2\2\u037c\u00c2\3\2\2\2\u037d\u037e\7^\2\2\u037e"+
+		"\u0389\5\u008fH\2\u037f\u0380\7^\2\2\u0380\u0381\5\u008fH\2\u0381\u0382"+
+		"\5\u008fH\2\u0382\u0389\3\2\2\2\u0383\u0384\7^\2\2\u0384\u0385\5\u00c5"+
+		"c\2\u0385\u0386\5\u008fH\2\u0386\u0387\5\u008fH\2\u0387\u0389\3\2\2\2"+
+		"\u0388\u037d\3\2\2\2\u0388\u037f\3\2\2\2\u0388\u0383\3\2\2\2\u0389\u00c4"+
+		"\3\2\2\2\u038a\u038b\t\20\2\2\u038b\u00c6\3\2\2\2\u038c\u038d\7^\2\2\u038d"+
+		"\u038e\7w\2\2\u038e\u038f\5\u0085C\2\u038f\u0390\5\u0085C\2\u0390\u0391"+
+		"\5\u0085C\2\u0391\u0392\5\u0085C\2\u0392\u00c8\3\2\2\2\u0393\u0394\7p"+
+		"\2\2\u0394\u0395\7w\2\2\u0395\u0396\7n\2\2\u0396\u0397\7n\2\2\u0397\u00ca"+
+		"\3\2\2\2\u0398\u0399\7*\2\2\u0399\u00cc\3\2\2\2\u039a\u039b\7+\2\2\u039b"+
+		"\u00ce\3\2\2\2\u039c\u039d\7}\2\2\u039d\u00d0\3\2\2\2\u039e\u039f\7\177"+
+		"\2\2\u039f\u00d2\3\2\2\2\u03a0\u03a1\7]\2\2\u03a1\u00d4\3\2\2\2\u03a2"+
+		"\u03a3\7_\2\2\u03a3\u00d6\3\2\2\2\u03a4\u03a5\7=\2\2\u03a5\u00d8\3\2\2"+
+		"\2\u03a6\u03a7\7.\2\2\u03a7\u00da\3\2\2\2\u03a8\u03a9\7\60\2\2\u03a9\u00dc"+
+		"\3\2\2\2\u03aa\u03ab\7?\2\2\u03ab\u00de\3\2\2\2\u03ac\u03ad\7@\2\2\u03ad"+
+		"\u00e0\3\2\2\2\u03ae\u03af\7>\2\2\u03af\u00e2\3\2\2\2\u03b0\u03b1\7#\2"+
+		"\2\u03b1\u00e4\3\2\2\2\u03b2\u03b3\7\u0080\2\2\u03b3\u00e6\3\2\2\2\u03b4"+
+		"\u03b5\7A\2\2\u03b5\u00e8\3\2\2\2\u03b6\u03b7\7<\2\2\u03b7\u00ea\3\2\2"+
+		"\2\u03b8\u03b9\7?\2\2\u03b9\u03ba\7?\2\2\u03ba\u00ec\3\2\2\2\u03bb\u03bc"+
+		"\7>\2\2\u03bc\u03bd\7?\2\2\u03bd\u00ee\3\2\2\2\u03be\u03bf\7@\2\2\u03bf"+
+		"\u03c0\7?\2\2\u03c0\u00f0\3\2\2\2\u03c1\u03c2\7#\2\2\u03c2\u03c3\7?\2"+
+		"\2\u03c3\u00f2\3\2\2\2\u03c4\u03c5\7(\2\2\u03c5\u03c6\7(\2\2\u03c6\u00f4"+
+		"\3\2\2\2\u03c7\u03c8\7~\2\2\u03c8\u03c9\7~\2\2\u03c9\u00f6\3\2\2\2\u03ca"+
+		"\u03cb\7-\2\2\u03cb\u03cc\7-\2\2\u03cc\u00f8\3\2\2\2\u03cd\u03ce\7/\2"+
+		"\2\u03ce\u03cf\7/\2\2\u03cf\u00fa\3\2\2\2\u03d0\u03d1\7-\2\2\u03d1\u00fc"+
+		"\3\2\2\2\u03d2\u03d3\7/\2\2\u03d3\u00fe\3\2\2\2\u03d4\u03d5\7,\2\2\u03d5"+
+		"\u0100\3\2\2\2\u03d6\u03d7\7\61\2\2\u03d7\u0102\3\2\2\2\u03d8\u03d9\7"+
+		"(\2\2\u03d9\u0104\3\2\2\2\u03da\u03db\7~\2\2\u03db\u0106\3\2\2\2\u03dc"+
+		"\u03dd\7`\2\2\u03dd\u0108\3\2\2\2\u03de\u03df\7\'\2\2\u03df\u010a\3\2"+
+		"\2\2\u03e0\u03e1\7/\2\2\u03e1\u03e2\7@\2\2\u03e2\u010c\3\2\2\2\u03e3\u03e4"+
+		"\7<\2\2\u03e4\u03e5\7<\2\2\u03e5\u010e\3\2\2\2\u03e6\u03e7\7-\2\2\u03e7"+
+		"\u03e8\7?\2\2\u03e8\u0110\3\2\2\2\u03e9\u03ea\7/\2\2\u03ea\u03eb\7?\2"+
+		"\2\u03eb\u0112\3\2\2\2\u03ec\u03ed\7,\2\2\u03ed\u03ee\7?\2\2\u03ee\u0114"+
+		"\3\2\2\2\u03ef\u03f0\7\61\2\2\u03f0\u03f1\7?\2\2\u03f1\u0116\3\2\2\2\u03f2"+
+		"\u03f3\7(\2\2\u03f3\u03f4\7?\2\2\u03f4\u0118\3\2\2\2\u03f5\u03f6\7~\2"+
+		"\2\u03f6\u03f7\7?\2\2\u03f7\u011a\3\2\2\2\u03f8\u03f9\7`\2\2\u03f9\u03fa"+
+		"\7?\2\2\u03fa\u011c\3\2\2\2\u03fb\u03fc\7\'\2\2\u03fc\u03fd\7?\2\2\u03fd"+
+		"\u011e\3\2\2\2\u03fe\u03ff\7>\2\2\u03ff\u0400\7>\2\2\u0400\u0401\7?\2"+
+		"\2\u0401\u0120\3\2\2\2\u0402\u0403\7@\2\2\u0403\u0404\7@\2\2\u0404\u0405"+
+		"\7?\2\2\u0405\u0122\3\2\2\2\u0406\u0407\7@\2\2\u0407\u0408\7@\2\2\u0408"+
+		"\u0409\7@\2\2\u0409\u040a\7?\2\2\u040a\u0124\3\2\2\2\u040b\u040f\5\u0127"+
+		"\u0094\2\u040c\u040e\5\u0129\u0095\2\u040d\u040c\3\2\2\2\u040e\u0411\3"+
+		"\2\2\2\u040f\u040d\3\2\2\2\u040f\u0410\3\2\2\2\u0410\u0126\3\2\2\2\u0411"+
+		"\u040f\3\2\2\2\u0412\u0419\t\21\2\2\u0413\u0414\n\22\2\2\u0414\u0419\6"+
+		"\u0094\2\2\u0415\u0416\t\23\2\2\u0416\u0417\t\24\2\2\u0417\u0419\6\u0094"+
+		"\3\2\u0418\u0412\3\2\2\2\u0418\u0413\3\2\2\2\u0418\u0415\3\2\2\2\u0419"+
+		"\u0128\3\2\2\2\u041a\u0421\t\25\2\2\u041b\u041c\n\22\2\2\u041c\u0421\6"+
+		"\u0095\4\2\u041d\u041e\t\23\2\2\u041e\u041f\t\24\2\2\u041f\u0421\6\u0095"+
+		"\5\2\u0420\u041a\3\2\2\2\u0420\u041b\3\2\2\2\u0420\u041d\3\2\2\2\u0421"+
+		"\u012a\3\2\2\2\u0422\u0423\7B\2\2\u0423\u012c\3\2\2\2\u0424\u0425\7\60"+
+		"\2\2\u0425\u0426\7\60\2\2\u0426\u0427\7\60\2\2\u0427\u012e\3\2\2\2\u0428"+
+		"\u042a\t\26\2\2\u0429\u0428\3\2\2\2\u042a\u042b\3\2\2\2\u042b\u0429\3"+
+		"\2\2\2\u042b\u042c\3\2\2\2\u042c\u042d\3\2\2\2\u042d\u042e\b\u0098\2\2"+
+		"\u042e\u0130\3\2\2\2\u042f\u0430\7\61\2\2\u0430\u0431\7,\2\2\u0431\u0435"+
+		"\3\2\2\2\u0432\u0434\13\2\2\2\u0433\u0432\3\2\2\2\u0434\u0437\3\2\2\2"+
+		"\u0435\u0436\3\2\2\2\u0435\u0433\3\2\2\2\u0436\u0438\3\2\2\2\u0437\u0435"+
+		"\3\2\2\2\u0438\u0439\7,\2\2\u0439\u043a\7\61\2\2\u043a\u043b\3\2\2\2\u043b"+
+		"\u043c\b\u0099\2\2\u043c\u0132\3\2\2\2\u043d\u043e\7\61\2\2\u043e\u043f"+
+		"\7\61\2\2\u043f\u0443\3\2\2\2\u0440\u0442\n\27\2\2\u0441\u0440\3\2\2\2"+
+		"\u0442\u0445\3\2\2\2\u0443\u0441\3\2\2\2\u0443\u0444\3\2\2\2\u0444\u0446"+
+		"\3\2\2\2\u0445\u0443\3\2\2\2\u0446\u0447\b\u009a\2\2\u0447\u0134\3\2\2"+
+		"\28\2\u028c\u0290\u0294\u0298\u029c\u02a3\u02a8\u02aa\u02ae\u02b1\u02b5"+
+		"\u02bc\u02c0\u02c5\u02cd\u02d0\u02d7\u02db\u02df\u02e5\u02e8\u02ef\u02f3"+
+		"\u02fb\u02fe\u0305\u0309\u030d\u0312\u0315\u0318\u031d\u0320\u0325\u032a"+
+		"\u0332\u033d\u0341\u0346\u034a\u035a\u0364\u036a\u0371\u0375\u037b\u0388"+
+		"\u040f\u0418\u0420\u042b\u0435\u0443\3\b\2\2";
+	public static final ATN _ATN =
+		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
+	static {
+		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
+		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
+			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.tokens b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.tokens
new file mode 100644
index 0000000..52ef1ee
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.tokens
@@ -0,0 +1,205 @@
+ABSTRACT=1
+ASSERT=2
+BOOLEAN=3
+BREAK=4
+BYTE=5
+CASE=6
+CATCH=7
+CHAR=8
+CLASS=9
+CONST=10
+CONTINUE=11
+DEFAULT=12
+DO=13
+DOUBLE=14
+ELSE=15
+ENUM=16
+EXTENDS=17
+FINAL=18
+FINALLY=19
+FLOAT=20
+FOR=21
+IF=22
+GOTO=23
+IMPLEMENTS=24
+IMPORT=25
+INSTANCEOF=26
+INT=27
+INTERFACE=28
+LONG=29
+NATIVE=30
+NEW=31
+PACKAGE=32
+PRIVATE=33
+PROTECTED=34
+PUBLIC=35
+RETURN=36
+SHORT=37
+STATIC=38
+STRICTFP=39
+SUPER=40
+SWITCH=41
+SYNCHRONIZED=42
+THIS=43
+THROW=44
+THROWS=45
+TRANSIENT=46
+TRY=47
+VOID=48
+VOLATILE=49
+WHILE=50
+IntegerLiteral=51
+FloatingPointLiteral=52
+BooleanLiteral=53
+CharacterLiteral=54
+StringLiteral=55
+NullLiteral=56
+LPAREN=57
+RPAREN=58
+LBRACE=59
+RBRACE=60
+LBRACK=61
+RBRACK=62
+SEMI=63
+COMMA=64
+DOT=65
+ASSIGN=66
+GT=67
+LT=68
+BANG=69
+TILDE=70
+QUESTION=71
+COLON=72
+EQUAL=73
+LE=74
+GE=75
+NOTEQUAL=76
+AND=77
+OR=78
+INC=79
+DEC=80
+ADD=81
+SUB=82
+MUL=83
+DIV=84
+BITAND=85
+BITOR=86
+CARET=87
+MOD=88
+ARROW=89
+COLONCOLON=90
+ADD_ASSIGN=91
+SUB_ASSIGN=92
+MUL_ASSIGN=93
+DIV_ASSIGN=94
+AND_ASSIGN=95
+OR_ASSIGN=96
+XOR_ASSIGN=97
+MOD_ASSIGN=98
+LSHIFT_ASSIGN=99
+RSHIFT_ASSIGN=100
+URSHIFT_ASSIGN=101
+Identifier=102
+AT=103
+ELLIPSIS=104
+WS=105
+COMMENT=106
+LINE_COMMENT=107
+'abstract'=1
+'assert'=2
+'boolean'=3
+'break'=4
+'byte'=5
+'case'=6
+'catch'=7
+'char'=8
+'class'=9
+'const'=10
+'continue'=11
+'default'=12
+'do'=13
+'double'=14
+'else'=15
+'enum'=16
+'extends'=17
+'final'=18
+'finally'=19
+'float'=20
+'for'=21
+'if'=22
+'goto'=23
+'implements'=24
+'import'=25
+'instanceof'=26
+'int'=27
+'interface'=28
+'long'=29
+'native'=30
+'new'=31
+'package'=32
+'private'=33
+'protected'=34
+'public'=35
+'return'=36
+'short'=37
+'static'=38
+'strictfp'=39
+'super'=40
+'switch'=41
+'synchronized'=42
+'this'=43
+'throw'=44
+'throws'=45
+'transient'=46
+'try'=47
+'void'=48
+'volatile'=49
+'while'=50
+'null'=56
+'('=57
+')'=58
+'{'=59
+'}'=60
+'['=61
+']'=62
+';'=63
+','=64
+'.'=65
+'='=66
+'>'=67
+'<'=68
+'!'=69
+'~'=70
+'?'=71
+':'=72
+'=='=73
+'<='=74
+'>='=75
+'!='=76
+'&&'=77
+'||'=78
+'++'=79
+'--'=80
+'+'=81
+'-'=82
+'*'=83
+'/'=84
+'&'=85
+'|'=86
+'^'=87
+'%'=88
+'->'=89
+'::'=90
+'+='=91
+'-='=92
+'*='=93
+'/='=94
+'&='=95
+'|='=96
+'^='=97
+'%='=98
+'<<='=99
+'>>='=100
+'>>>='=101
+'@'=103
+'...'=104
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java
new file mode 100644
index 0000000..409502c
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java
@@ -0,0 +1,1212 @@
+// Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\DroppingJava.g4 by ANTLR 4.5.1
+package ru.ftc.upc.testing.dropper.lang.gen;
+import org.antlr.v4.runtime.tree.ParseTreeListener;
+
+/**
+ * This interface defines a complete listener for a parse tree produced by
+ * {@link DroppingJavaParser}.
+ */
+public interface DroppingJavaListener extends ParseTreeListener {
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#primitiveType}.
+	 * @param ctx the parse tree
+	 */
+	void enterPrimitiveType(DroppingJavaParser.PrimitiveTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#primitiveType}.
+	 * @param ctx the parse tree
+	 */
+	void exitPrimitiveType(DroppingJavaParser.PrimitiveTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#numericType}.
+	 * @param ctx the parse tree
+	 */
+	void enterNumericType(DroppingJavaParser.NumericTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#numericType}.
+	 * @param ctx the parse tree
+	 */
+	void exitNumericType(DroppingJavaParser.NumericTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#integralType}.
+	 * @param ctx the parse tree
+	 */
+	void enterIntegralType(DroppingJavaParser.IntegralTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#integralType}.
+	 * @param ctx the parse tree
+	 */
+	void exitIntegralType(DroppingJavaParser.IntegralTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#floatingPointType}.
+	 * @param ctx the parse tree
+	 */
+	void enterFloatingPointType(DroppingJavaParser.FloatingPointTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#floatingPointType}.
+	 * @param ctx the parse tree
+	 */
+	void exitFloatingPointType(DroppingJavaParser.FloatingPointTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#referenceType}.
+	 * @param ctx the parse tree
+	 */
+	void enterReferenceType(DroppingJavaParser.ReferenceTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#referenceType}.
+	 * @param ctx the parse tree
+	 */
+	void exitReferenceType(DroppingJavaParser.ReferenceTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#classOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void enterClassOrInterfaceType(DroppingJavaParser.ClassOrInterfaceTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#classOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void exitClassOrInterfaceType(DroppingJavaParser.ClassOrInterfaceTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#classType}.
+	 * @param ctx the parse tree
+	 */
+	void enterClassType(DroppingJavaParser.ClassTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#classType}.
+	 * @param ctx the parse tree
+	 */
+	void exitClassType(DroppingJavaParser.ClassTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#classType_lf_classOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void enterClassType_lf_classOrInterfaceType(DroppingJavaParser.ClassType_lf_classOrInterfaceTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#classType_lf_classOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void exitClassType_lf_classOrInterfaceType(DroppingJavaParser.ClassType_lf_classOrInterfaceTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#classType_lfno_classOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void enterClassType_lfno_classOrInterfaceType(DroppingJavaParser.ClassType_lfno_classOrInterfaceTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#classType_lfno_classOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void exitClassType_lfno_classOrInterfaceType(DroppingJavaParser.ClassType_lfno_classOrInterfaceTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#interfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void enterInterfaceType(DroppingJavaParser.InterfaceTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#interfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void exitInterfaceType(DroppingJavaParser.InterfaceTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#interfaceType_lf_classOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void enterInterfaceType_lf_classOrInterfaceType(DroppingJavaParser.InterfaceType_lf_classOrInterfaceTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#interfaceType_lf_classOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void exitInterfaceType_lf_classOrInterfaceType(DroppingJavaParser.InterfaceType_lf_classOrInterfaceTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#interfaceType_lfno_classOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void enterInterfaceType_lfno_classOrInterfaceType(DroppingJavaParser.InterfaceType_lfno_classOrInterfaceTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#interfaceType_lfno_classOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void exitInterfaceType_lfno_classOrInterfaceType(DroppingJavaParser.InterfaceType_lfno_classOrInterfaceTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#typeVariable}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeVariable(DroppingJavaParser.TypeVariableContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#typeVariable}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeVariable(DroppingJavaParser.TypeVariableContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#arrayType}.
+	 * @param ctx the parse tree
+	 */
+	void enterArrayType(DroppingJavaParser.ArrayTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#arrayType}.
+	 * @param ctx the parse tree
+	 */
+	void exitArrayType(DroppingJavaParser.ArrayTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#dims}.
+	 * @param ctx the parse tree
+	 */
+	void enterDims(DroppingJavaParser.DimsContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#dims}.
+	 * @param ctx the parse tree
+	 */
+	void exitDims(DroppingJavaParser.DimsContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#typeParameter}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeParameter(DroppingJavaParser.TypeParameterContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#typeParameter}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeParameter(DroppingJavaParser.TypeParameterContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#typeParameterModifier}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeParameterModifier(DroppingJavaParser.TypeParameterModifierContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#typeParameterModifier}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeParameterModifier(DroppingJavaParser.TypeParameterModifierContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#typeBound}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeBound(DroppingJavaParser.TypeBoundContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#typeBound}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeBound(DroppingJavaParser.TypeBoundContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#additionalBound}.
+	 * @param ctx the parse tree
+	 */
+	void enterAdditionalBound(DroppingJavaParser.AdditionalBoundContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#additionalBound}.
+	 * @param ctx the parse tree
+	 */
+	void exitAdditionalBound(DroppingJavaParser.AdditionalBoundContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#typeArguments}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeArguments(DroppingJavaParser.TypeArgumentsContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#typeArguments}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeArguments(DroppingJavaParser.TypeArgumentsContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#typeArgumentList}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeArgumentList(DroppingJavaParser.TypeArgumentListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#typeArgumentList}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeArgumentList(DroppingJavaParser.TypeArgumentListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#typeArgument}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeArgument(DroppingJavaParser.TypeArgumentContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#typeArgument}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeArgument(DroppingJavaParser.TypeArgumentContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#wildcard}.
+	 * @param ctx the parse tree
+	 */
+	void enterWildcard(DroppingJavaParser.WildcardContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#wildcard}.
+	 * @param ctx the parse tree
+	 */
+	void exitWildcard(DroppingJavaParser.WildcardContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#wildcardBounds}.
+	 * @param ctx the parse tree
+	 */
+	void enterWildcardBounds(DroppingJavaParser.WildcardBoundsContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#wildcardBounds}.
+	 * @param ctx the parse tree
+	 */
+	void exitWildcardBounds(DroppingJavaParser.WildcardBoundsContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#typeName}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeName(DroppingJavaParser.TypeNameContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#typeName}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeName(DroppingJavaParser.TypeNameContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#packageOrTypeName}.
+	 * @param ctx the parse tree
+	 */
+	void enterPackageOrTypeName(DroppingJavaParser.PackageOrTypeNameContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#packageOrTypeName}.
+	 * @param ctx the parse tree
+	 */
+	void exitPackageOrTypeName(DroppingJavaParser.PackageOrTypeNameContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#expressionName}.
+	 * @param ctx the parse tree
+	 */
+	void enterExpressionName(DroppingJavaParser.ExpressionNameContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#expressionName}.
+	 * @param ctx the parse tree
+	 */
+	void exitExpressionName(DroppingJavaParser.ExpressionNameContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#ambiguousName}.
+	 * @param ctx the parse tree
+	 */
+	void enterAmbiguousName(DroppingJavaParser.AmbiguousNameContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#ambiguousName}.
+	 * @param ctx the parse tree
+	 */
+	void exitAmbiguousName(DroppingJavaParser.AmbiguousNameContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#compilationUnit}.
+	 * @param ctx the parse tree
+	 */
+	void enterCompilationUnit(DroppingJavaParser.CompilationUnitContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#compilationUnit}.
+	 * @param ctx the parse tree
+	 */
+	void exitCompilationUnit(DroppingJavaParser.CompilationUnitContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#packageDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterPackageDeclaration(DroppingJavaParser.PackageDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#packageDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitPackageDeclaration(DroppingJavaParser.PackageDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#packageModifier}.
+	 * @param ctx the parse tree
+	 */
+	void enterPackageModifier(DroppingJavaParser.PackageModifierContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#packageModifier}.
+	 * @param ctx the parse tree
+	 */
+	void exitPackageModifier(DroppingJavaParser.PackageModifierContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#importDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterImportDeclaration(DroppingJavaParser.ImportDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#importDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitImportDeclaration(DroppingJavaParser.ImportDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#singleTypeImportDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterSingleTypeImportDeclaration(DroppingJavaParser.SingleTypeImportDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#singleTypeImportDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitSingleTypeImportDeclaration(DroppingJavaParser.SingleTypeImportDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#typeImportOnDemandDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeImportOnDemandDeclaration(DroppingJavaParser.TypeImportOnDemandDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#typeImportOnDemandDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeImportOnDemandDeclaration(DroppingJavaParser.TypeImportOnDemandDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#singleStaticImportDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterSingleStaticImportDeclaration(DroppingJavaParser.SingleStaticImportDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#singleStaticImportDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitSingleStaticImportDeclaration(DroppingJavaParser.SingleStaticImportDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#staticImportOnDemandDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterStaticImportOnDemandDeclaration(DroppingJavaParser.StaticImportOnDemandDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#staticImportOnDemandDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitStaticImportOnDemandDeclaration(DroppingJavaParser.StaticImportOnDemandDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#typeDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeDeclaration(DroppingJavaParser.TypeDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#typeDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeDeclaration(DroppingJavaParser.TypeDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#classDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterClassDeclaration(DroppingJavaParser.ClassDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#classDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitClassDeclaration(DroppingJavaParser.ClassDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code ClassName}
+	 * labeled alternative in {@link DroppingJavaParser#normalClassDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterClassName(DroppingJavaParser.ClassNameContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code ClassName}
+	 * labeled alternative in {@link DroppingJavaParser#normalClassDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitClassName(DroppingJavaParser.ClassNameContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#classModifier}.
+	 * @param ctx the parse tree
+	 */
+	void enterClassModifier(DroppingJavaParser.ClassModifierContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#classModifier}.
+	 * @param ctx the parse tree
+	 */
+	void exitClassModifier(DroppingJavaParser.ClassModifierContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#typeParameters}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeParameters(DroppingJavaParser.TypeParametersContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#typeParameters}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeParameters(DroppingJavaParser.TypeParametersContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#typeParameterList}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeParameterList(DroppingJavaParser.TypeParameterListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#typeParameterList}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeParameterList(DroppingJavaParser.TypeParameterListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#superclass}.
+	 * @param ctx the parse tree
+	 */
+	void enterSuperclass(DroppingJavaParser.SuperclassContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#superclass}.
+	 * @param ctx the parse tree
+	 */
+	void exitSuperclass(DroppingJavaParser.SuperclassContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#superinterfaces}.
+	 * @param ctx the parse tree
+	 */
+	void enterSuperinterfaces(DroppingJavaParser.SuperinterfacesContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#superinterfaces}.
+	 * @param ctx the parse tree
+	 */
+	void exitSuperinterfaces(DroppingJavaParser.SuperinterfacesContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#interfaceTypeList}.
+	 * @param ctx the parse tree
+	 */
+	void enterInterfaceTypeList(DroppingJavaParser.InterfaceTypeListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#interfaceTypeList}.
+	 * @param ctx the parse tree
+	 */
+	void exitInterfaceTypeList(DroppingJavaParser.InterfaceTypeListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#classBody}.
+	 * @param ctx the parse tree
+	 */
+	void enterClassBody(DroppingJavaParser.ClassBodyContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#classBody}.
+	 * @param ctx the parse tree
+	 */
+	void exitClassBody(DroppingJavaParser.ClassBodyContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#classBodyDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterClassBodyDeclaration(DroppingJavaParser.ClassBodyDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#classBodyDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitClassBodyDeclaration(DroppingJavaParser.ClassBodyDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#classMemberDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterClassMemberDeclaration(DroppingJavaParser.ClassMemberDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#classMemberDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitClassMemberDeclaration(DroppingJavaParser.ClassMemberDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#fieldDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterFieldDeclaration(DroppingJavaParser.FieldDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#fieldDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitFieldDeclaration(DroppingJavaParser.FieldDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#variableDeclaratorId}.
+	 * @param ctx the parse tree
+	 */
+	void enterVariableDeclaratorId(DroppingJavaParser.VariableDeclaratorIdContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#variableDeclaratorId}.
+	 * @param ctx the parse tree
+	 */
+	void exitVariableDeclaratorId(DroppingJavaParser.VariableDeclaratorIdContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#variableInitializer}.
+	 * @param ctx the parse tree
+	 */
+	void enterVariableInitializer(DroppingJavaParser.VariableInitializerContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#variableInitializer}.
+	 * @param ctx the parse tree
+	 */
+	void exitVariableInitializer(DroppingJavaParser.VariableInitializerContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#unannType}.
+	 * @param ctx the parse tree
+	 */
+	void enterUnannType(DroppingJavaParser.UnannTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#unannType}.
+	 * @param ctx the parse tree
+	 */
+	void exitUnannType(DroppingJavaParser.UnannTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#unannPrimitiveType}.
+	 * @param ctx the parse tree
+	 */
+	void enterUnannPrimitiveType(DroppingJavaParser.UnannPrimitiveTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#unannPrimitiveType}.
+	 * @param ctx the parse tree
+	 */
+	void exitUnannPrimitiveType(DroppingJavaParser.UnannPrimitiveTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#unannReferenceType}.
+	 * @param ctx the parse tree
+	 */
+	void enterUnannReferenceType(DroppingJavaParser.UnannReferenceTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#unannReferenceType}.
+	 * @param ctx the parse tree
+	 */
+	void exitUnannReferenceType(DroppingJavaParser.UnannReferenceTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#unannClassOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void enterUnannClassOrInterfaceType(DroppingJavaParser.UnannClassOrInterfaceTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#unannClassOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void exitUnannClassOrInterfaceType(DroppingJavaParser.UnannClassOrInterfaceTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#unannClassType_lf_unannClassOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void enterUnannClassType_lf_unannClassOrInterfaceType(DroppingJavaParser.UnannClassType_lf_unannClassOrInterfaceTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#unannClassType_lf_unannClassOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void exitUnannClassType_lf_unannClassOrInterfaceType(DroppingJavaParser.UnannClassType_lf_unannClassOrInterfaceTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#unannClassType_lfno_unannClassOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void enterUnannClassType_lfno_unannClassOrInterfaceType(DroppingJavaParser.UnannClassType_lfno_unannClassOrInterfaceTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#unannClassType_lfno_unannClassOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void exitUnannClassType_lfno_unannClassOrInterfaceType(DroppingJavaParser.UnannClassType_lfno_unannClassOrInterfaceTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#unannInterfaceType_lf_unannClassOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void enterUnannInterfaceType_lf_unannClassOrInterfaceType(DroppingJavaParser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#unannInterfaceType_lf_unannClassOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void exitUnannInterfaceType_lf_unannClassOrInterfaceType(DroppingJavaParser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#unannInterfaceType_lfno_unannClassOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void enterUnannInterfaceType_lfno_unannClassOrInterfaceType(DroppingJavaParser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#unannInterfaceType_lfno_unannClassOrInterfaceType}.
+	 * @param ctx the parse tree
+	 */
+	void exitUnannInterfaceType_lfno_unannClassOrInterfaceType(DroppingJavaParser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#unannTypeVariable}.
+	 * @param ctx the parse tree
+	 */
+	void enterUnannTypeVariable(DroppingJavaParser.UnannTypeVariableContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#unannTypeVariable}.
+	 * @param ctx the parse tree
+	 */
+	void exitUnannTypeVariable(DroppingJavaParser.UnannTypeVariableContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#unannArrayType}.
+	 * @param ctx the parse tree
+	 */
+	void enterUnannArrayType(DroppingJavaParser.UnannArrayTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#unannArrayType}.
+	 * @param ctx the parse tree
+	 */
+	void exitUnannArrayType(DroppingJavaParser.UnannArrayTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#methodDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterMethodDeclaration(DroppingJavaParser.MethodDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#methodDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitMethodDeclaration(DroppingJavaParser.MethodDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#methodModifier}.
+	 * @param ctx the parse tree
+	 */
+	void enterMethodModifier(DroppingJavaParser.MethodModifierContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#methodModifier}.
+	 * @param ctx the parse tree
+	 */
+	void exitMethodModifier(DroppingJavaParser.MethodModifierContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#methodHeader}.
+	 * @param ctx the parse tree
+	 */
+	void enterMethodHeader(DroppingJavaParser.MethodHeaderContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#methodHeader}.
+	 * @param ctx the parse tree
+	 */
+	void exitMethodHeader(DroppingJavaParser.MethodHeaderContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#result}.
+	 * @param ctx the parse tree
+	 */
+	void enterResult(DroppingJavaParser.ResultContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#result}.
+	 * @param ctx the parse tree
+	 */
+	void exitResult(DroppingJavaParser.ResultContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code MethodName}
+	 * labeled alternative in {@link DroppingJavaParser#methodDeclarator}.
+	 * @param ctx the parse tree
+	 */
+	void enterMethodName(DroppingJavaParser.MethodNameContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code MethodName}
+	 * labeled alternative in {@link DroppingJavaParser#methodDeclarator}.
+	 * @param ctx the parse tree
+	 */
+	void exitMethodName(DroppingJavaParser.MethodNameContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#formalParameterList}.
+	 * @param ctx the parse tree
+	 */
+	void enterFormalParameterList(DroppingJavaParser.FormalParameterListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#formalParameterList}.
+	 * @param ctx the parse tree
+	 */
+	void exitFormalParameterList(DroppingJavaParser.FormalParameterListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#formalParameters}.
+	 * @param ctx the parse tree
+	 */
+	void enterFormalParameters(DroppingJavaParser.FormalParametersContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#formalParameters}.
+	 * @param ctx the parse tree
+	 */
+	void exitFormalParameters(DroppingJavaParser.FormalParametersContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#formalParameter}.
+	 * @param ctx the parse tree
+	 */
+	void enterFormalParameter(DroppingJavaParser.FormalParameterContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#formalParameter}.
+	 * @param ctx the parse tree
+	 */
+	void exitFormalParameter(DroppingJavaParser.FormalParameterContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#variableModifier}.
+	 * @param ctx the parse tree
+	 */
+	void enterVariableModifier(DroppingJavaParser.VariableModifierContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#variableModifier}.
+	 * @param ctx the parse tree
+	 */
+	void exitVariableModifier(DroppingJavaParser.VariableModifierContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#lastFormalParameter}.
+	 * @param ctx the parse tree
+	 */
+	void enterLastFormalParameter(DroppingJavaParser.LastFormalParameterContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#lastFormalParameter}.
+	 * @param ctx the parse tree
+	 */
+	void exitLastFormalParameter(DroppingJavaParser.LastFormalParameterContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#receiverParameter}.
+	 * @param ctx the parse tree
+	 */
+	void enterReceiverParameter(DroppingJavaParser.ReceiverParameterContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#receiverParameter}.
+	 * @param ctx the parse tree
+	 */
+	void exitReceiverParameter(DroppingJavaParser.ReceiverParameterContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#throws_}.
+	 * @param ctx the parse tree
+	 */
+	void enterThrows_(DroppingJavaParser.Throws_Context ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#throws_}.
+	 * @param ctx the parse tree
+	 */
+	void exitThrows_(DroppingJavaParser.Throws_Context ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#exceptionTypeList}.
+	 * @param ctx the parse tree
+	 */
+	void enterExceptionTypeList(DroppingJavaParser.ExceptionTypeListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#exceptionTypeList}.
+	 * @param ctx the parse tree
+	 */
+	void exitExceptionTypeList(DroppingJavaParser.ExceptionTypeListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#exceptionType}.
+	 * @param ctx the parse tree
+	 */
+	void enterExceptionType(DroppingJavaParser.ExceptionTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#exceptionType}.
+	 * @param ctx the parse tree
+	 */
+	void exitExceptionType(DroppingJavaParser.ExceptionTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#methodBody}.
+	 * @param ctx the parse tree
+	 */
+	void enterMethodBody(DroppingJavaParser.MethodBodyContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#methodBody}.
+	 * @param ctx the parse tree
+	 */
+	void exitMethodBody(DroppingJavaParser.MethodBodyContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#instanceInitializer}.
+	 * @param ctx the parse tree
+	 */
+	void enterInstanceInitializer(DroppingJavaParser.InstanceInitializerContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#instanceInitializer}.
+	 * @param ctx the parse tree
+	 */
+	void exitInstanceInitializer(DroppingJavaParser.InstanceInitializerContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#staticInitializer}.
+	 * @param ctx the parse tree
+	 */
+	void enterStaticInitializer(DroppingJavaParser.StaticInitializerContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#staticInitializer}.
+	 * @param ctx the parse tree
+	 */
+	void exitStaticInitializer(DroppingJavaParser.StaticInitializerContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#constructorDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterConstructorDeclaration(DroppingJavaParser.ConstructorDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#constructorDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitConstructorDeclaration(DroppingJavaParser.ConstructorDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#constructorModifier}.
+	 * @param ctx the parse tree
+	 */
+	void enterConstructorModifier(DroppingJavaParser.ConstructorModifierContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#constructorModifier}.
+	 * @param ctx the parse tree
+	 */
+	void exitConstructorModifier(DroppingJavaParser.ConstructorModifierContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#constructorDeclarator}.
+	 * @param ctx the parse tree
+	 */
+	void enterConstructorDeclarator(DroppingJavaParser.ConstructorDeclaratorContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#constructorDeclarator}.
+	 * @param ctx the parse tree
+	 */
+	void exitConstructorDeclarator(DroppingJavaParser.ConstructorDeclaratorContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code ConstructorName}
+	 * labeled alternative in {@link DroppingJavaParser#simpleTypeName}.
+	 * @param ctx the parse tree
+	 */
+	void enterConstructorName(DroppingJavaParser.ConstructorNameContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code ConstructorName}
+	 * labeled alternative in {@link DroppingJavaParser#simpleTypeName}.
+	 * @param ctx the parse tree
+	 */
+	void exitConstructorName(DroppingJavaParser.ConstructorNameContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#constructorBody}.
+	 * @param ctx the parse tree
+	 */
+	void enterConstructorBody(DroppingJavaParser.ConstructorBodyContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#constructorBody}.
+	 * @param ctx the parse tree
+	 */
+	void exitConstructorBody(DroppingJavaParser.ConstructorBodyContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#explicitConstructorInvocation}.
+	 * @param ctx the parse tree
+	 */
+	void enterExplicitConstructorInvocation(DroppingJavaParser.ExplicitConstructorInvocationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#explicitConstructorInvocation}.
+	 * @param ctx the parse tree
+	 */
+	void exitExplicitConstructorInvocation(DroppingJavaParser.ExplicitConstructorInvocationContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code EnumName}
+	 * labeled alternative in {@link DroppingJavaParser#enumDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterEnumName(DroppingJavaParser.EnumNameContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code EnumName}
+	 * labeled alternative in {@link DroppingJavaParser#enumDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitEnumName(DroppingJavaParser.EnumNameContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#enumBody}.
+	 * @param ctx the parse tree
+	 */
+	void enterEnumBody(DroppingJavaParser.EnumBodyContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#enumBody}.
+	 * @param ctx the parse tree
+	 */
+	void exitEnumBody(DroppingJavaParser.EnumBodyContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#enumConstantList}.
+	 * @param ctx the parse tree
+	 */
+	void enterEnumConstantList(DroppingJavaParser.EnumConstantListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#enumConstantList}.
+	 * @param ctx the parse tree
+	 */
+	void exitEnumConstantList(DroppingJavaParser.EnumConstantListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#enumConstant}.
+	 * @param ctx the parse tree
+	 */
+	void enterEnumConstant(DroppingJavaParser.EnumConstantContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#enumConstant}.
+	 * @param ctx the parse tree
+	 */
+	void exitEnumConstant(DroppingJavaParser.EnumConstantContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#enumConstantModifier}.
+	 * @param ctx the parse tree
+	 */
+	void enterEnumConstantModifier(DroppingJavaParser.EnumConstantModifierContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#enumConstantModifier}.
+	 * @param ctx the parse tree
+	 */
+	void exitEnumConstantModifier(DroppingJavaParser.EnumConstantModifierContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#enumBodyDeclarations}.
+	 * @param ctx the parse tree
+	 */
+	void enterEnumBodyDeclarations(DroppingJavaParser.EnumBodyDeclarationsContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#enumBodyDeclarations}.
+	 * @param ctx the parse tree
+	 */
+	void exitEnumBodyDeclarations(DroppingJavaParser.EnumBodyDeclarationsContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#argumentList}.
+	 * @param ctx the parse tree
+	 */
+	void enterArgumentList(DroppingJavaParser.ArgumentListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#argumentList}.
+	 * @param ctx the parse tree
+	 */
+	void exitArgumentList(DroppingJavaParser.ArgumentListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void enterExpression(DroppingJavaParser.ExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#expression}.
+	 * @param ctx the parse tree
+	 */
+	void exitExpression(DroppingJavaParser.ExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#conditionalExpression}.
+	 * @param ctx the parse tree
+	 */
+	void enterConditionalExpression(DroppingJavaParser.ConditionalExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#conditionalExpression}.
+	 * @param ctx the parse tree
+	 */
+	void exitConditionalExpression(DroppingJavaParser.ConditionalExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#primary}.
+	 * @param ctx the parse tree
+	 */
+	void enterPrimary(DroppingJavaParser.PrimaryContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#primary}.
+	 * @param ctx the parse tree
+	 */
+	void exitPrimary(DroppingJavaParser.PrimaryContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#interfaceDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterInterfaceDeclaration(DroppingJavaParser.InterfaceDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#interfaceDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitInterfaceDeclaration(DroppingJavaParser.InterfaceDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code IfaceName}
+	 * labeled alternative in {@link DroppingJavaParser#normalInterfaceDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterIfaceName(DroppingJavaParser.IfaceNameContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code IfaceName}
+	 * labeled alternative in {@link DroppingJavaParser#normalInterfaceDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitIfaceName(DroppingJavaParser.IfaceNameContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#interfaceModifier}.
+	 * @param ctx the parse tree
+	 */
+	void enterInterfaceModifier(DroppingJavaParser.InterfaceModifierContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#interfaceModifier}.
+	 * @param ctx the parse tree
+	 */
+	void exitInterfaceModifier(DroppingJavaParser.InterfaceModifierContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#extendsInterfaces}.
+	 * @param ctx the parse tree
+	 */
+	void enterExtendsInterfaces(DroppingJavaParser.ExtendsInterfacesContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#extendsInterfaces}.
+	 * @param ctx the parse tree
+	 */
+	void exitExtendsInterfaces(DroppingJavaParser.ExtendsInterfacesContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#interfaceBody}.
+	 * @param ctx the parse tree
+	 */
+	void enterInterfaceBody(DroppingJavaParser.InterfaceBodyContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#interfaceBody}.
+	 * @param ctx the parse tree
+	 */
+	void exitInterfaceBody(DroppingJavaParser.InterfaceBodyContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#interfaceMemberDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterInterfaceMemberDeclaration(DroppingJavaParser.InterfaceMemberDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#interfaceMemberDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitInterfaceMemberDeclaration(DroppingJavaParser.InterfaceMemberDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#constantDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterConstantDeclaration(DroppingJavaParser.ConstantDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#constantDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitConstantDeclaration(DroppingJavaParser.ConstantDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#constantModifier}.
+	 * @param ctx the parse tree
+	 */
+	void enterConstantModifier(DroppingJavaParser.ConstantModifierContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#constantModifier}.
+	 * @param ctx the parse tree
+	 */
+	void exitConstantModifier(DroppingJavaParser.ConstantModifierContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#interfaceMethodDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterInterfaceMethodDeclaration(DroppingJavaParser.InterfaceMethodDeclarationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#interfaceMethodDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitInterfaceMethodDeclaration(DroppingJavaParser.InterfaceMethodDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#interfaceMethodModifier}.
+	 * @param ctx the parse tree
+	 */
+	void enterInterfaceMethodModifier(DroppingJavaParser.InterfaceMethodModifierContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#interfaceMethodModifier}.
+	 * @param ctx the parse tree
+	 */
+	void exitInterfaceMethodModifier(DroppingJavaParser.InterfaceMethodModifierContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code AnnoName}
+	 * labeled alternative in {@link DroppingJavaParser#annotationTypeDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void enterAnnoName(DroppingJavaParser.AnnoNameContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code AnnoName}
+	 * labeled alternative in {@link DroppingJavaParser#annotationTypeDeclaration}.
+	 * @param ctx the parse tree
+	 */
+	void exitAnnoName(DroppingJavaParser.AnnoNameContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#annotationTypeBody}.
+	 * @param ctx the parse tree
+	 */
+	void enterAnnotationTypeBody(DroppingJavaParser.AnnotationTypeBodyContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#annotationTypeBody}.
+	 * @param ctx the parse tree
+	 */
+	void exitAnnotationTypeBody(DroppingJavaParser.AnnotationTypeBodyContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#annotation}.
+	 * @param ctx the parse tree
+	 */
+	void enterAnnotation(DroppingJavaParser.AnnotationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#annotation}.
+	 * @param ctx the parse tree
+	 */
+	void exitAnnotation(DroppingJavaParser.AnnotationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#normalAnnotation}.
+	 * @param ctx the parse tree
+	 */
+	void enterNormalAnnotation(DroppingJavaParser.NormalAnnotationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#normalAnnotation}.
+	 * @param ctx the parse tree
+	 */
+	void exitNormalAnnotation(DroppingJavaParser.NormalAnnotationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#elementValuePairList}.
+	 * @param ctx the parse tree
+	 */
+	void enterElementValuePairList(DroppingJavaParser.ElementValuePairListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#elementValuePairList}.
+	 * @param ctx the parse tree
+	 */
+	void exitElementValuePairList(DroppingJavaParser.ElementValuePairListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#elementValuePair}.
+	 * @param ctx the parse tree
+	 */
+	void enterElementValuePair(DroppingJavaParser.ElementValuePairContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#elementValuePair}.
+	 * @param ctx the parse tree
+	 */
+	void exitElementValuePair(DroppingJavaParser.ElementValuePairContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#elementValue}.
+	 * @param ctx the parse tree
+	 */
+	void enterElementValue(DroppingJavaParser.ElementValueContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#elementValue}.
+	 * @param ctx the parse tree
+	 */
+	void exitElementValue(DroppingJavaParser.ElementValueContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#elementValueArrayInitializer}.
+	 * @param ctx the parse tree
+	 */
+	void enterElementValueArrayInitializer(DroppingJavaParser.ElementValueArrayInitializerContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#elementValueArrayInitializer}.
+	 * @param ctx the parse tree
+	 */
+	void exitElementValueArrayInitializer(DroppingJavaParser.ElementValueArrayInitializerContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#elementValueList}.
+	 * @param ctx the parse tree
+	 */
+	void enterElementValueList(DroppingJavaParser.ElementValueListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#elementValueList}.
+	 * @param ctx the parse tree
+	 */
+	void exitElementValueList(DroppingJavaParser.ElementValueListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#markerAnnotation}.
+	 * @param ctx the parse tree
+	 */
+	void enterMarkerAnnotation(DroppingJavaParser.MarkerAnnotationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#markerAnnotation}.
+	 * @param ctx the parse tree
+	 */
+	void exitMarkerAnnotation(DroppingJavaParser.MarkerAnnotationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#singleElementAnnotation}.
+	 * @param ctx the parse tree
+	 */
+	void enterSingleElementAnnotation(DroppingJavaParser.SingleElementAnnotationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#singleElementAnnotation}.
+	 * @param ctx the parse tree
+	 */
+	void exitSingleElementAnnotation(DroppingJavaParser.SingleElementAnnotationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#arrayInitializer}.
+	 * @param ctx the parse tree
+	 */
+	void enterArrayInitializer(DroppingJavaParser.ArrayInitializerContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#arrayInitializer}.
+	 * @param ctx the parse tree
+	 */
+	void exitArrayInitializer(DroppingJavaParser.ArrayInitializerContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#variableInitializerList}.
+	 * @param ctx the parse tree
+	 */
+	void enterVariableInitializerList(DroppingJavaParser.VariableInitializerListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#variableInitializerList}.
+	 * @param ctx the parse tree
+	 */
+	void exitVariableInitializerList(DroppingJavaParser.VariableInitializerListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#block}.
+	 * @param ctx the parse tree
+	 */
+	void enterBlock(DroppingJavaParser.BlockContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#block}.
+	 * @param ctx the parse tree
+	 */
+	void exitBlock(DroppingJavaParser.BlockContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#blockStatements}.
+	 * @param ctx the parse tree
+	 */
+	void enterBlockStatements(DroppingJavaParser.BlockStatementsContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#blockStatements}.
+	 * @param ctx the parse tree
+	 */
+	void exitBlockStatements(DroppingJavaParser.BlockStatementsContext ctx);
+}
\ No newline at end of file
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java
new file mode 100644
index 0000000..9d758e6
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java
@@ -0,0 +1,8310 @@
+// Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\DroppingJava.g4 by ANTLR 4.5.1
+package ru.ftc.upc.testing.dropper.lang.gen;
+
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.atn.ATN;
+import org.antlr.v4.runtime.atn.ATNDeserializer;
+import org.antlr.v4.runtime.atn.ParserATNSimulator;
+import org.antlr.v4.runtime.atn.PredictionContextCache;
+import org.antlr.v4.runtime.dfa.DFA;
+import org.antlr.v4.runtime.tree.ParseTreeListener;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+import java.util.List;
+
+@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
+public class DroppingJavaParser extends Parser {
+	static { RuntimeMetaData.checkVersion("4.5.1", RuntimeMetaData.VERSION); }
+
+	protected static final DFA[] _decisionToDFA;
+	protected static final PredictionContextCache _sharedContextCache =
+		new PredictionContextCache();
+	public static final int
+		ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8, 
+		CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15, 
+		ENUM=16, EXTENDS=17, FINAL=18, FINALLY=19, FLOAT=20, FOR=21, IF=22, GOTO=23, 
+		IMPLEMENTS=24, IMPORT=25, INSTANCEOF=26, INT=27, INTERFACE=28, LONG=29, 
+		NATIVE=30, NEW=31, PACKAGE=32, PRIVATE=33, PROTECTED=34, PUBLIC=35, RETURN=36, 
+		SHORT=37, STATIC=38, STRICTFP=39, SUPER=40, SWITCH=41, SYNCHRONIZED=42, 
+		THIS=43, THROW=44, THROWS=45, TRANSIENT=46, TRY=47, VOID=48, VOLATILE=49, 
+		WHILE=50, IntegerLiteral=51, FloatingPointLiteral=52, BooleanLiteral=53, 
+		CharacterLiteral=54, StringLiteral=55, NullLiteral=56, LPAREN=57, RPAREN=58, 
+		LBRACE=59, RBRACE=60, LBRACK=61, RBRACK=62, SEMI=63, COMMA=64, DOT=65, 
+		ASSIGN=66, GT=67, LT=68, BANG=69, TILDE=70, QUESTION=71, COLON=72, EQUAL=73, 
+		LE=74, GE=75, NOTEQUAL=76, AND=77, OR=78, INC=79, DEC=80, ADD=81, SUB=82, 
+		MUL=83, DIV=84, BITAND=85, BITOR=86, CARET=87, MOD=88, ARROW=89, COLONCOLON=90, 
+		ADD_ASSIGN=91, SUB_ASSIGN=92, MUL_ASSIGN=93, DIV_ASSIGN=94, AND_ASSIGN=95, 
+		OR_ASSIGN=96, XOR_ASSIGN=97, MOD_ASSIGN=98, LSHIFT_ASSIGN=99, RSHIFT_ASSIGN=100, 
+		URSHIFT_ASSIGN=101, Identifier=102, AT=103, ELLIPSIS=104, WS=105, COMMENT=106, 
+		LINE_COMMENT=107;
+	public static final int
+		RULE_primitiveType = 0, RULE_numericType = 1, RULE_integralType = 2, RULE_floatingPointType = 3, 
+		RULE_referenceType = 4, RULE_classOrInterfaceType = 5, RULE_classType = 6, 
+		RULE_classType_lf_classOrInterfaceType = 7, RULE_classType_lfno_classOrInterfaceType = 8, 
+		RULE_interfaceType = 9, RULE_interfaceType_lf_classOrInterfaceType = 10, 
+		RULE_interfaceType_lfno_classOrInterfaceType = 11, RULE_typeVariable = 12, 
+		RULE_arrayType = 13, RULE_dims = 14, RULE_typeParameter = 15, RULE_typeParameterModifier = 16, 
+		RULE_typeBound = 17, RULE_additionalBound = 18, RULE_typeArguments = 19, 
+		RULE_typeArgumentList = 20, RULE_typeArgument = 21, RULE_wildcard = 22, 
+		RULE_wildcardBounds = 23, RULE_typeName = 24, RULE_packageOrTypeName = 25, 
+		RULE_expressionName = 26, RULE_ambiguousName = 27, RULE_compilationUnit = 28, 
+		RULE_packageDeclaration = 29, RULE_packageModifier = 30, RULE_importDeclaration = 31, 
+		RULE_singleTypeImportDeclaration = 32, RULE_typeImportOnDemandDeclaration = 33, 
+		RULE_singleStaticImportDeclaration = 34, RULE_staticImportOnDemandDeclaration = 35, 
+		RULE_typeDeclaration = 36, RULE_classDeclaration = 37, RULE_normalClassDeclaration = 38, 
+		RULE_classModifier = 39, RULE_typeParameters = 40, RULE_typeParameterList = 41, 
+		RULE_superclass = 42, RULE_superinterfaces = 43, RULE_interfaceTypeList = 44, 
+		RULE_classBody = 45, RULE_classBodyDeclaration = 46, RULE_classMemberDeclaration = 47, 
+		RULE_fieldDeclaration = 48, RULE_variableDeclaratorId = 49, RULE_variableInitializer = 50, 
+		RULE_unannType = 51, RULE_unannPrimitiveType = 52, RULE_unannReferenceType = 53, 
+		RULE_unannClassOrInterfaceType = 54, RULE_unannClassType_lf_unannClassOrInterfaceType = 55, 
+		RULE_unannClassType_lfno_unannClassOrInterfaceType = 56, RULE_unannInterfaceType_lf_unannClassOrInterfaceType = 57, 
+		RULE_unannInterfaceType_lfno_unannClassOrInterfaceType = 58, RULE_unannTypeVariable = 59, 
+		RULE_unannArrayType = 60, RULE_methodDeclaration = 61, RULE_methodModifier = 62, 
+		RULE_methodHeader = 63, RULE_result = 64, RULE_methodDeclarator = 65, 
+		RULE_formalParameterList = 66, RULE_formalParameters = 67, RULE_formalParameter = 68, 
+		RULE_variableModifier = 69, RULE_lastFormalParameter = 70, RULE_receiverParameter = 71, 
+		RULE_throws_ = 72, RULE_exceptionTypeList = 73, RULE_exceptionType = 74, 
+		RULE_methodBody = 75, RULE_instanceInitializer = 76, RULE_staticInitializer = 77, 
+		RULE_constructorDeclaration = 78, RULE_constructorModifier = 79, RULE_constructorDeclarator = 80, 
+		RULE_simpleTypeName = 81, RULE_constructorBody = 82, RULE_explicitConstructorInvocation = 83, 
+		RULE_enumDeclaration = 84, RULE_enumBody = 85, RULE_enumConstantList = 86, 
+		RULE_enumConstant = 87, RULE_enumConstantModifier = 88, RULE_enumBodyDeclarations = 89, 
+		RULE_argumentList = 90, RULE_expression = 91, RULE_conditionalExpression = 92, 
+		RULE_primary = 93, RULE_interfaceDeclaration = 94, RULE_normalInterfaceDeclaration = 95, 
+		RULE_interfaceModifier = 96, RULE_extendsInterfaces = 97, RULE_interfaceBody = 98, 
+		RULE_interfaceMemberDeclaration = 99, RULE_constantDeclaration = 100, 
+		RULE_constantModifier = 101, RULE_interfaceMethodDeclaration = 102, RULE_interfaceMethodModifier = 103, 
+		RULE_annotationTypeDeclaration = 104, RULE_annotationTypeBody = 105, RULE_annotation = 106, 
+		RULE_normalAnnotation = 107, RULE_elementValuePairList = 108, RULE_elementValuePair = 109, 
+		RULE_elementValue = 110, RULE_elementValueArrayInitializer = 111, RULE_elementValueList = 112, 
+		RULE_markerAnnotation = 113, RULE_singleElementAnnotation = 114, RULE_arrayInitializer = 115, 
+		RULE_variableInitializerList = 116, RULE_block = 117, RULE_blockStatements = 118;
+	public static final String[] ruleNames = {
+		"primitiveType", "numericType", "integralType", "floatingPointType", "referenceType", 
+		"classOrInterfaceType", "classType", "classType_lf_classOrInterfaceType", 
+		"classType_lfno_classOrInterfaceType", "interfaceType", "interfaceType_lf_classOrInterfaceType", 
+		"interfaceType_lfno_classOrInterfaceType", "typeVariable", "arrayType", 
+		"dims", "typeParameter", "typeParameterModifier", "typeBound", "additionalBound", 
+		"typeArguments", "typeArgumentList", "typeArgument", "wildcard", "wildcardBounds", 
+		"typeName", "packageOrTypeName", "expressionName", "ambiguousName", "compilationUnit", 
+		"packageDeclaration", "packageModifier", "importDeclaration", "singleTypeImportDeclaration", 
+		"typeImportOnDemandDeclaration", "singleStaticImportDeclaration", "staticImportOnDemandDeclaration", 
+		"typeDeclaration", "classDeclaration", "normalClassDeclaration", "classModifier", 
+		"typeParameters", "typeParameterList", "superclass", "superinterfaces", 
+		"interfaceTypeList", "classBody", "classBodyDeclaration", "classMemberDeclaration", 
+		"fieldDeclaration", "variableDeclaratorId", "variableInitializer", "unannType", 
+		"unannPrimitiveType", "unannReferenceType", "unannClassOrInterfaceType", 
+		"unannClassType_lf_unannClassOrInterfaceType", "unannClassType_lfno_unannClassOrInterfaceType", 
+		"unannInterfaceType_lf_unannClassOrInterfaceType", "unannInterfaceType_lfno_unannClassOrInterfaceType", 
+		"unannTypeVariable", "unannArrayType", "methodDeclaration", "methodModifier", 
+		"methodHeader", "result", "methodDeclarator", "formalParameterList", "formalParameters", 
+		"formalParameter", "variableModifier", "lastFormalParameter", "receiverParameter", 
+		"throws_", "exceptionTypeList", "exceptionType", "methodBody", "instanceInitializer", 
+		"staticInitializer", "constructorDeclaration", "constructorModifier", 
+		"constructorDeclarator", "simpleTypeName", "constructorBody", "explicitConstructorInvocation", 
+		"enumDeclaration", "enumBody", "enumConstantList", "enumConstant", "enumConstantModifier", 
+		"enumBodyDeclarations", "argumentList", "expression", "conditionalExpression", 
+		"primary", "interfaceDeclaration", "normalInterfaceDeclaration", "interfaceModifier", 
+		"extendsInterfaces", "interfaceBody", "interfaceMemberDeclaration", "constantDeclaration", 
+		"constantModifier", "interfaceMethodDeclaration", "interfaceMethodModifier", 
+		"annotationTypeDeclaration", "annotationTypeBody", "annotation", "normalAnnotation", 
+		"elementValuePairList", "elementValuePair", "elementValue", "elementValueArrayInitializer", 
+		"elementValueList", "markerAnnotation", "singleElementAnnotation", "arrayInitializer", 
+		"variableInitializerList", "block", "blockStatements"
+	};
+
+	private static final String[] _LITERAL_NAMES = {
+		null, "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", "'case'", 
+		"'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", 
+		"'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", 
+		"'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", 
+		"'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", 
+		"'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", 
+		"'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", 
+		"'transient'", "'try'", "'void'", "'volatile'", "'while'", null, null, 
+		null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", 
+		"';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", 
+		"'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", 
+		"'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", 
+		"'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", 
+		"'>>>='", null, "'@'", "'...'"
+	};
+	private static final String[] _SYMBOLIC_NAMES = {
+		null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", 
+		"CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", 
+		"ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", 
+		"IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", 
+		"PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", 
+		"SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", 
+		"TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "FloatingPointLiteral", 
+		"BooleanLiteral", "CharacterLiteral", "StringLiteral", "NullLiteral", 
+		"LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", 
+		"DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", "COLON", "EQUAL", 
+		"LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", "SUB", "MUL", 
+		"DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", "ADD_ASSIGN", 
+		"SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", 
+		"MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", 
+		"AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT"
+	};
+	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
+
+	/**
+	 * @deprecated Use {@link #VOCABULARY} instead.
+	 */
+	@Deprecated
+	public static final String[] tokenNames;
+	static {
+		tokenNames = new String[_SYMBOLIC_NAMES.length];
+		for (int i = 0; i < tokenNames.length; i++) {
+			tokenNames[i] = VOCABULARY.getLiteralName(i);
+			if (tokenNames[i] == null) {
+				tokenNames[i] = VOCABULARY.getSymbolicName(i);
+			}
+
+			if (tokenNames[i] == null) {
+				tokenNames[i] = "<INVALID>";
+			}
+		}
+	}
+
+	@Override
+	@Deprecated
+	public String[] getTokenNames() {
+		return tokenNames;
+	}
+
+	@Override
+
+	public Vocabulary getVocabulary() {
+		return VOCABULARY;
+	}
+
+	@Override
+	public String getGrammarFileName() { return "DroppingJava.g4"; }
+
+	@Override
+	public String[] getRuleNames() { return ruleNames; }
+
+	@Override
+	public String getSerializedATN() { return _serializedATN; }
+
+	@Override
+	public ATN getATN() { return _ATN; }
+
+	public DroppingJavaParser(TokenStream input) {
+		super(input);
+		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
+	}
+	public static class PrimitiveTypeContext extends ParserRuleContext {
+		public NumericTypeContext numericType() {
+			return getRuleContext(NumericTypeContext.class,0);
+		}
+		public List<AnnotationContext> annotation() {
+			return getRuleContexts(AnnotationContext.class);
+		}
+		public AnnotationContext annotation(int i) {
+			return getRuleContext(AnnotationContext.class,i);
+		}
+		public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_primitiveType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterPrimitiveType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitPrimitiveType(this);
+		}
+	}
+
+	public final PrimitiveTypeContext primitiveType() throws RecognitionException {
+		PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState());
+		enterRule(_localctx, 0, RULE_primitiveType);
+		int _la;
+		try {
+			setState(252);
+			switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(241);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==AT) {
+					{
+					{
+					setState(238);
+					annotation();
+					}
+					}
+					setState(243);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(244);
+				numericType();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(248);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==AT) {
+					{
+					{
+					setState(245);
+					annotation();
+					}
+					}
+					setState(250);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(251);
+				match(BOOLEAN);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class NumericTypeContext extends ParserRuleContext {
+		public IntegralTypeContext integralType() {
+			return getRuleContext(IntegralTypeContext.class,0);
+		}
+		public FloatingPointTypeContext floatingPointType() {
+			return getRuleContext(FloatingPointTypeContext.class,0);
+		}
+		public NumericTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_numericType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterNumericType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitNumericType(this);
+		}
+	}
+
+	public final NumericTypeContext numericType() throws RecognitionException {
+		NumericTypeContext _localctx = new NumericTypeContext(_ctx, getState());
+		enterRule(_localctx, 2, RULE_numericType);
+		try {
+			setState(256);
+			switch (_input.LA(1)) {
+			case BYTE:
+			case CHAR:
+			case INT:
+			case LONG:
+			case SHORT:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(254);
+				integralType();
+				}
+				break;
+			case DOUBLE:
+			case FLOAT:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(255);
+				floatingPointType();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class IntegralTypeContext extends ParserRuleContext {
+		public IntegralTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_integralType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterIntegralType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitIntegralType(this);
+		}
+	}
+
+	public final IntegralTypeContext integralType() throws RecognitionException {
+		IntegralTypeContext _localctx = new IntegralTypeContext(_ctx, getState());
+		enterRule(_localctx, 4, RULE_integralType);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(258);
+			_la = _input.LA(1);
+			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BYTE) | (1L << CHAR) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0)) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class FloatingPointTypeContext extends ParserRuleContext {
+		public FloatingPointTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_floatingPointType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterFloatingPointType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitFloatingPointType(this);
+		}
+	}
+
+	public final FloatingPointTypeContext floatingPointType() throws RecognitionException {
+		FloatingPointTypeContext _localctx = new FloatingPointTypeContext(_ctx, getState());
+		enterRule(_localctx, 6, RULE_floatingPointType);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(260);
+			_la = _input.LA(1);
+			if ( !(_la==DOUBLE || _la==FLOAT) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ReferenceTypeContext extends ParserRuleContext {
+		public ClassOrInterfaceTypeContext classOrInterfaceType() {
+			return getRuleContext(ClassOrInterfaceTypeContext.class,0);
+		}
+		public TypeVariableContext typeVariable() {
+			return getRuleContext(TypeVariableContext.class,0);
+		}
+		public ArrayTypeContext arrayType() {
+			return getRuleContext(ArrayTypeContext.class,0);
+		}
+		public ReferenceTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_referenceType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterReferenceType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitReferenceType(this);
+		}
+	}
+
+	public final ReferenceTypeContext referenceType() throws RecognitionException {
+		ReferenceTypeContext _localctx = new ReferenceTypeContext(_ctx, getState());
+		enterRule(_localctx, 8, RULE_referenceType);
+		try {
+			setState(265);
+			switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(262);
+				classOrInterfaceType();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(263);
+				typeVariable();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(264);
+				arrayType();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ClassOrInterfaceTypeContext extends ParserRuleContext {
+		public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() {
+			return getRuleContext(ClassType_lfno_classOrInterfaceTypeContext.class,0);
+		}
+		public InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() {
+			return getRuleContext(InterfaceType_lfno_classOrInterfaceTypeContext.class,0);
+		}
+		public List<ClassType_lf_classOrInterfaceTypeContext> classType_lf_classOrInterfaceType() {
+			return getRuleContexts(ClassType_lf_classOrInterfaceTypeContext.class);
+		}
+		public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType(int i) {
+			return getRuleContext(ClassType_lf_classOrInterfaceTypeContext.class,i);
+		}
+		public List<InterfaceType_lf_classOrInterfaceTypeContext> interfaceType_lf_classOrInterfaceType() {
+			return getRuleContexts(InterfaceType_lf_classOrInterfaceTypeContext.class);
+		}
+		public InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType(int i) {
+			return getRuleContext(InterfaceType_lf_classOrInterfaceTypeContext.class,i);
+		}
+		public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_classOrInterfaceType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterClassOrInterfaceType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassOrInterfaceType(this);
+		}
+	}
+
+	public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException {
+		ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState());
+		enterRule(_localctx, 10, RULE_classOrInterfaceType);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(269);
+			switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
+			case 1:
+				{
+				setState(267);
+				classType_lfno_classOrInterfaceType();
+				}
+				break;
+			case 2:
+				{
+				setState(268);
+				interfaceType_lfno_classOrInterfaceType();
+				}
+				break;
+			}
+			setState(275);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					setState(273);
+					switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
+					case 1:
+						{
+						setState(271);
+						classType_lf_classOrInterfaceType();
+						}
+						break;
+					case 2:
+						{
+						setState(272);
+						interfaceType_lf_classOrInterfaceType();
+						}
+						break;
+					}
+					} 
+				}
+				setState(277);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ClassTypeContext extends ParserRuleContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public List<AnnotationContext> annotation() {
+			return getRuleContexts(AnnotationContext.class);
+		}
+		public AnnotationContext annotation(int i) {
+			return getRuleContext(AnnotationContext.class,i);
+		}
+		public TypeArgumentsContext typeArguments() {
+			return getRuleContext(TypeArgumentsContext.class,0);
+		}
+		public ClassOrInterfaceTypeContext classOrInterfaceType() {
+			return getRuleContext(ClassOrInterfaceTypeContext.class,0);
+		}
+		public ClassTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_classType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterClassType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassType(this);
+		}
+	}
+
+	public final ClassTypeContext classType() throws RecognitionException {
+		ClassTypeContext _localctx = new ClassTypeContext(_ctx, getState());
+		enterRule(_localctx, 12, RULE_classType);
+		int _la;
+		try {
+			setState(300);
+			switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(281);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==AT) {
+					{
+					{
+					setState(278);
+					annotation();
+					}
+					}
+					setState(283);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(284);
+				match(Identifier);
+				setState(286);
+				_la = _input.LA(1);
+				if (_la==LT) {
+					{
+					setState(285);
+					typeArguments();
+					}
+				}
+
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(288);
+				classOrInterfaceType();
+				setState(289);
+				match(DOT);
+				setState(293);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==AT) {
+					{
+					{
+					setState(290);
+					annotation();
+					}
+					}
+					setState(295);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(296);
+				match(Identifier);
+				setState(298);
+				_la = _input.LA(1);
+				if (_la==LT) {
+					{
+					setState(297);
+					typeArguments();
+					}
+				}
+
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ClassType_lf_classOrInterfaceTypeContext extends ParserRuleContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public List<AnnotationContext> annotation() {
+			return getRuleContexts(AnnotationContext.class);
+		}
+		public AnnotationContext annotation(int i) {
+			return getRuleContext(AnnotationContext.class,i);
+		}
+		public TypeArgumentsContext typeArguments() {
+			return getRuleContext(TypeArgumentsContext.class,0);
+		}
+		public ClassType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_classType_lf_classOrInterfaceType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterClassType_lf_classOrInterfaceType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassType_lf_classOrInterfaceType(this);
+		}
+	}
+
+	public final ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() throws RecognitionException {
+		ClassType_lf_classOrInterfaceTypeContext _localctx = new ClassType_lf_classOrInterfaceTypeContext(_ctx, getState());
+		enterRule(_localctx, 14, RULE_classType_lf_classOrInterfaceType);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(302);
+			match(DOT);
+			setState(306);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==AT) {
+				{
+				{
+				setState(303);
+				annotation();
+				}
+				}
+				setState(308);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(309);
+			match(Identifier);
+			setState(311);
+			_la = _input.LA(1);
+			if (_la==LT) {
+				{
+				setState(310);
+				typeArguments();
+				}
+			}
+
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ClassType_lfno_classOrInterfaceTypeContext extends ParserRuleContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public List<AnnotationContext> annotation() {
+			return getRuleContexts(AnnotationContext.class);
+		}
+		public AnnotationContext annotation(int i) {
+			return getRuleContext(AnnotationContext.class,i);
+		}
+		public TypeArgumentsContext typeArguments() {
+			return getRuleContext(TypeArgumentsContext.class,0);
+		}
+		public ClassType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_classType_lfno_classOrInterfaceType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterClassType_lfno_classOrInterfaceType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassType_lfno_classOrInterfaceType(this);
+		}
+	}
+
+	public final ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() throws RecognitionException {
+		ClassType_lfno_classOrInterfaceTypeContext _localctx = new ClassType_lfno_classOrInterfaceTypeContext(_ctx, getState());
+		enterRule(_localctx, 16, RULE_classType_lfno_classOrInterfaceType);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(316);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==AT) {
+				{
+				{
+				setState(313);
+				annotation();
+				}
+				}
+				setState(318);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(319);
+			match(Identifier);
+			setState(321);
+			_la = _input.LA(1);
+			if (_la==LT) {
+				{
+				setState(320);
+				typeArguments();
+				}
+			}
+
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InterfaceTypeContext extends ParserRuleContext {
+		public ClassTypeContext classType() {
+			return getRuleContext(ClassTypeContext.class,0);
+		}
+		public InterfaceTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_interfaceType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterInterfaceType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceType(this);
+		}
+	}
+
+	public final InterfaceTypeContext interfaceType() throws RecognitionException {
+		InterfaceTypeContext _localctx = new InterfaceTypeContext(_ctx, getState());
+		enterRule(_localctx, 18, RULE_interfaceType);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(323);
+			classType();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InterfaceType_lf_classOrInterfaceTypeContext extends ParserRuleContext {
+		public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() {
+			return getRuleContext(ClassType_lf_classOrInterfaceTypeContext.class,0);
+		}
+		public InterfaceType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_interfaceType_lf_classOrInterfaceType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterInterfaceType_lf_classOrInterfaceType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceType_lf_classOrInterfaceType(this);
+		}
+	}
+
+	public final InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType() throws RecognitionException {
+		InterfaceType_lf_classOrInterfaceTypeContext _localctx = new InterfaceType_lf_classOrInterfaceTypeContext(_ctx, getState());
+		enterRule(_localctx, 20, RULE_interfaceType_lf_classOrInterfaceType);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(325);
+			classType_lf_classOrInterfaceType();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InterfaceType_lfno_classOrInterfaceTypeContext extends ParserRuleContext {
+		public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() {
+			return getRuleContext(ClassType_lfno_classOrInterfaceTypeContext.class,0);
+		}
+		public InterfaceType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_interfaceType_lfno_classOrInterfaceType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterInterfaceType_lfno_classOrInterfaceType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceType_lfno_classOrInterfaceType(this);
+		}
+	}
+
+	public final InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() throws RecognitionException {
+		InterfaceType_lfno_classOrInterfaceTypeContext _localctx = new InterfaceType_lfno_classOrInterfaceTypeContext(_ctx, getState());
+		enterRule(_localctx, 22, RULE_interfaceType_lfno_classOrInterfaceType);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(327);
+			classType_lfno_classOrInterfaceType();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeVariableContext extends ParserRuleContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public List<AnnotationContext> annotation() {
+			return getRuleContexts(AnnotationContext.class);
+		}
+		public AnnotationContext annotation(int i) {
+			return getRuleContext(AnnotationContext.class,i);
+		}
+		public TypeVariableContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeVariable; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterTypeVariable(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeVariable(this);
+		}
+	}
+
+	public final TypeVariableContext typeVariable() throws RecognitionException {
+		TypeVariableContext _localctx = new TypeVariableContext(_ctx, getState());
+		enterRule(_localctx, 24, RULE_typeVariable);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(332);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==AT) {
+				{
+				{
+				setState(329);
+				annotation();
+				}
+				}
+				setState(334);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(335);
+			match(Identifier);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ArrayTypeContext extends ParserRuleContext {
+		public PrimitiveTypeContext primitiveType() {
+			return getRuleContext(PrimitiveTypeContext.class,0);
+		}
+		public DimsContext dims() {
+			return getRuleContext(DimsContext.class,0);
+		}
+		public ClassOrInterfaceTypeContext classOrInterfaceType() {
+			return getRuleContext(ClassOrInterfaceTypeContext.class,0);
+		}
+		public TypeVariableContext typeVariable() {
+			return getRuleContext(TypeVariableContext.class,0);
+		}
+		public ArrayTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_arrayType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterArrayType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitArrayType(this);
+		}
+	}
+
+	public final ArrayTypeContext arrayType() throws RecognitionException {
+		ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState());
+		enterRule(_localctx, 26, RULE_arrayType);
+		try {
+			setState(346);
+			switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(337);
+				primitiveType();
+				setState(338);
+				dims();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(340);
+				classOrInterfaceType();
+				setState(341);
+				dims();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(343);
+				typeVariable();
+				setState(344);
+				dims();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class DimsContext extends ParserRuleContext {
+		public List<AnnotationContext> annotation() {
+			return getRuleContexts(AnnotationContext.class);
+		}
+		public AnnotationContext annotation(int i) {
+			return getRuleContext(AnnotationContext.class,i);
+		}
+		public DimsContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_dims; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterDims(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitDims(this);
+		}
+	}
+
+	public final DimsContext dims() throws RecognitionException {
+		DimsContext _localctx = new DimsContext(_ctx, getState());
+		enterRule(_localctx, 28, RULE_dims);
+		int _la;
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(351);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==AT) {
+				{
+				{
+				setState(348);
+				annotation();
+				}
+				}
+				setState(353);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(354);
+			match(LBRACK);
+			setState(355);
+			match(RBRACK);
+			setState(366);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(359);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+					while (_la==AT) {
+						{
+						{
+						setState(356);
+						annotation();
+						}
+						}
+						setState(361);
+						_errHandler.sync(this);
+						_la = _input.LA(1);
+					}
+					setState(362);
+					match(LBRACK);
+					setState(363);
+					match(RBRACK);
+					}
+					} 
+				}
+				setState(368);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeParameterContext extends ParserRuleContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public List<TypeParameterModifierContext> typeParameterModifier() {
+			return getRuleContexts(TypeParameterModifierContext.class);
+		}
+		public TypeParameterModifierContext typeParameterModifier(int i) {
+			return getRuleContext(TypeParameterModifierContext.class,i);
+		}
+		public TypeBoundContext typeBound() {
+			return getRuleContext(TypeBoundContext.class,0);
+		}
+		public TypeParameterContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeParameter; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterTypeParameter(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeParameter(this);
+		}
+	}
+
+	public final TypeParameterContext typeParameter() throws RecognitionException {
+		TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState());
+		enterRule(_localctx, 30, RULE_typeParameter);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(372);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==AT) {
+				{
+				{
+				setState(369);
+				typeParameterModifier();
+				}
+				}
+				setState(374);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(375);
+			match(Identifier);
+			setState(377);
+			_la = _input.LA(1);
+			if (_la==EXTENDS) {
+				{
+				setState(376);
+				typeBound();
+				}
+			}
+
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeParameterModifierContext extends ParserRuleContext {
+		public AnnotationContext annotation() {
+			return getRuleContext(AnnotationContext.class,0);
+		}
+		public TypeParameterModifierContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeParameterModifier; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterTypeParameterModifier(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeParameterModifier(this);
+		}
+	}
+
+	public final TypeParameterModifierContext typeParameterModifier() throws RecognitionException {
+		TypeParameterModifierContext _localctx = new TypeParameterModifierContext(_ctx, getState());
+		enterRule(_localctx, 32, RULE_typeParameterModifier);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(379);
+			annotation();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeBoundContext extends ParserRuleContext {
+		public TypeVariableContext typeVariable() {
+			return getRuleContext(TypeVariableContext.class,0);
+		}
+		public ClassOrInterfaceTypeContext classOrInterfaceType() {
+			return getRuleContext(ClassOrInterfaceTypeContext.class,0);
+		}
+		public List<AdditionalBoundContext> additionalBound() {
+			return getRuleContexts(AdditionalBoundContext.class);
+		}
+		public AdditionalBoundContext additionalBound(int i) {
+			return getRuleContext(AdditionalBoundContext.class,i);
+		}
+		public TypeBoundContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeBound; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterTypeBound(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeBound(this);
+		}
+	}
+
+	public final TypeBoundContext typeBound() throws RecognitionException {
+		TypeBoundContext _localctx = new TypeBoundContext(_ctx, getState());
+		enterRule(_localctx, 34, RULE_typeBound);
+		int _la;
+		try {
+			setState(391);
+			switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(381);
+				match(EXTENDS);
+				setState(382);
+				typeVariable();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(383);
+				match(EXTENDS);
+				setState(384);
+				classOrInterfaceType();
+				setState(388);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==BITAND) {
+					{
+					{
+					setState(385);
+					additionalBound();
+					}
+					}
+					setState(390);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class AdditionalBoundContext extends ParserRuleContext {
+		public InterfaceTypeContext interfaceType() {
+			return getRuleContext(InterfaceTypeContext.class,0);
+		}
+		public AdditionalBoundContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_additionalBound; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterAdditionalBound(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitAdditionalBound(this);
+		}
+	}
+
+	public final AdditionalBoundContext additionalBound() throws RecognitionException {
+		AdditionalBoundContext _localctx = new AdditionalBoundContext(_ctx, getState());
+		enterRule(_localctx, 36, RULE_additionalBound);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(393);
+			match(BITAND);
+			setState(394);
+			interfaceType();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeArgumentsContext extends ParserRuleContext {
+		public TypeArgumentListContext typeArgumentList() {
+			return getRuleContext(TypeArgumentListContext.class,0);
+		}
+		public TypeArgumentsContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeArguments; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterTypeArguments(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeArguments(this);
+		}
+	}
+
+	public final TypeArgumentsContext typeArguments() throws RecognitionException {
+		TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState());
+		enterRule(_localctx, 38, RULE_typeArguments);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(396);
+			match(LT);
+			setState(397);
+			typeArgumentList();
+			setState(398);
+			match(GT);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeArgumentListContext extends ParserRuleContext {
+		public List<TypeArgumentContext> typeArgument() {
+			return getRuleContexts(TypeArgumentContext.class);
+		}
+		public TypeArgumentContext typeArgument(int i) {
+			return getRuleContext(TypeArgumentContext.class,i);
+		}
+		public TypeArgumentListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeArgumentList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterTypeArgumentList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeArgumentList(this);
+		}
+	}
+
+	public final TypeArgumentListContext typeArgumentList() throws RecognitionException {
+		TypeArgumentListContext _localctx = new TypeArgumentListContext(_ctx, getState());
+		enterRule(_localctx, 40, RULE_typeArgumentList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(400);
+			typeArgument();
+			setState(405);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==COMMA) {
+				{
+				{
+				setState(401);
+				match(COMMA);
+				setState(402);
+				typeArgument();
+				}
+				}
+				setState(407);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeArgumentContext extends ParserRuleContext {
+		public ReferenceTypeContext referenceType() {
+			return getRuleContext(ReferenceTypeContext.class,0);
+		}
+		public WildcardContext wildcard() {
+			return getRuleContext(WildcardContext.class,0);
+		}
+		public TypeArgumentContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeArgument; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterTypeArgument(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeArgument(this);
+		}
+	}
+
+	public final TypeArgumentContext typeArgument() throws RecognitionException {
+		TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState());
+		enterRule(_localctx, 42, RULE_typeArgument);
+		try {
+			setState(410);
+			switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(408);
+				referenceType();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(409);
+				wildcard();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class WildcardContext extends ParserRuleContext {
+		public List<AnnotationContext> annotation() {
+			return getRuleContexts(AnnotationContext.class);
+		}
+		public AnnotationContext annotation(int i) {
+			return getRuleContext(AnnotationContext.class,i);
+		}
+		public WildcardBoundsContext wildcardBounds() {
+			return getRuleContext(WildcardBoundsContext.class,0);
+		}
+		public WildcardContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_wildcard; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterWildcard(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitWildcard(this);
+		}
+	}
+
+	public final WildcardContext wildcard() throws RecognitionException {
+		WildcardContext _localctx = new WildcardContext(_ctx, getState());
+		enterRule(_localctx, 44, RULE_wildcard);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(415);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==AT) {
+				{
+				{
+				setState(412);
+				annotation();
+				}
+				}
+				setState(417);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(418);
+			match(QUESTION);
+			setState(420);
+			_la = _input.LA(1);
+			if (_la==EXTENDS || _la==SUPER) {
+				{
+				setState(419);
+				wildcardBounds();
+				}
+			}
+
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class WildcardBoundsContext extends ParserRuleContext {
+		public ReferenceTypeContext referenceType() {
+			return getRuleContext(ReferenceTypeContext.class,0);
+		}
+		public WildcardBoundsContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_wildcardBounds; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterWildcardBounds(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitWildcardBounds(this);
+		}
+	}
+
+	public final WildcardBoundsContext wildcardBounds() throws RecognitionException {
+		WildcardBoundsContext _localctx = new WildcardBoundsContext(_ctx, getState());
+		enterRule(_localctx, 46, RULE_wildcardBounds);
+		try {
+			setState(426);
+			switch (_input.LA(1)) {
+			case EXTENDS:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(422);
+				match(EXTENDS);
+				setState(423);
+				referenceType();
+				}
+				break;
+			case SUPER:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(424);
+				match(SUPER);
+				setState(425);
+				referenceType();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeNameContext extends ParserRuleContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public PackageOrTypeNameContext packageOrTypeName() {
+			return getRuleContext(PackageOrTypeNameContext.class,0);
+		}
+		public TypeNameContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeName; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterTypeName(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeName(this);
+		}
+	}
+
+	public final TypeNameContext typeName() throws RecognitionException {
+		TypeNameContext _localctx = new TypeNameContext(_ctx, getState());
+		enterRule(_localctx, 48, RULE_typeName);
+		try {
+			setState(433);
+			switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(428);
+				match(Identifier);
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(429);
+				packageOrTypeName(0);
+				setState(430);
+				match(DOT);
+				setState(431);
+				match(Identifier);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class PackageOrTypeNameContext extends ParserRuleContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public PackageOrTypeNameContext packageOrTypeName() {
+			return getRuleContext(PackageOrTypeNameContext.class,0);
+		}
+		public PackageOrTypeNameContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_packageOrTypeName; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterPackageOrTypeName(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitPackageOrTypeName(this);
+		}
+	}
+
+	public final PackageOrTypeNameContext packageOrTypeName() throws RecognitionException {
+		return packageOrTypeName(0);
+	}
+
+	private PackageOrTypeNameContext packageOrTypeName(int _p) throws RecognitionException {
+		ParserRuleContext _parentctx = _ctx;
+		int _parentState = getState();
+		PackageOrTypeNameContext _localctx = new PackageOrTypeNameContext(_ctx, _parentState);
+		PackageOrTypeNameContext _prevctx = _localctx;
+		int _startState = 50;
+		enterRecursionRule(_localctx, 50, RULE_packageOrTypeName, _p);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			{
+			setState(436);
+			match(Identifier);
+			}
+			_ctx.stop = _input.LT(-1);
+			setState(443);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,32,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					if ( _parseListeners!=null ) triggerExitRuleEvent();
+					_prevctx = _localctx;
+					{
+					{
+					_localctx = new PackageOrTypeNameContext(_parentctx, _parentState);
+					pushNewRecursionContext(_localctx, _startState, RULE_packageOrTypeName);
+					setState(438);
+					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
+					setState(439);
+					match(DOT);
+					setState(440);
+					match(Identifier);
+					}
+					} 
+				}
+				setState(445);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,32,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			unrollRecursionContexts(_parentctx);
+		}
+		return _localctx;
+	}
+
+	public static class ExpressionNameContext extends ParserRuleContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public AmbiguousNameContext ambiguousName() {
+			return getRuleContext(AmbiguousNameContext.class,0);
+		}
+		public ExpressionNameContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_expressionName; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterExpressionName(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitExpressionName(this);
+		}
+	}
+
+	public final ExpressionNameContext expressionName() throws RecognitionException {
+		ExpressionNameContext _localctx = new ExpressionNameContext(_ctx, getState());
+		enterRule(_localctx, 52, RULE_expressionName);
+		try {
+			setState(451);
+			switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(446);
+				match(Identifier);
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(447);
+				ambiguousName(0);
+				setState(448);
+				match(DOT);
+				setState(449);
+				match(Identifier);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class AmbiguousNameContext extends ParserRuleContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public AmbiguousNameContext ambiguousName() {
+			return getRuleContext(AmbiguousNameContext.class,0);
+		}
+		public AmbiguousNameContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_ambiguousName; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterAmbiguousName(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitAmbiguousName(this);
+		}
+	}
+
+	public final AmbiguousNameContext ambiguousName() throws RecognitionException {
+		return ambiguousName(0);
+	}
+
+	private AmbiguousNameContext ambiguousName(int _p) throws RecognitionException {
+		ParserRuleContext _parentctx = _ctx;
+		int _parentState = getState();
+		AmbiguousNameContext _localctx = new AmbiguousNameContext(_ctx, _parentState);
+		AmbiguousNameContext _prevctx = _localctx;
+		int _startState = 54;
+		enterRecursionRule(_localctx, 54, RULE_ambiguousName, _p);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			{
+			setState(454);
+			match(Identifier);
+			}
+			_ctx.stop = _input.LT(-1);
+			setState(461);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,34,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					if ( _parseListeners!=null ) triggerExitRuleEvent();
+					_prevctx = _localctx;
+					{
+					{
+					_localctx = new AmbiguousNameContext(_parentctx, _parentState);
+					pushNewRecursionContext(_localctx, _startState, RULE_ambiguousName);
+					setState(456);
+					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
+					setState(457);
+					match(DOT);
+					setState(458);
+					match(Identifier);
+					}
+					} 
+				}
+				setState(463);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,34,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			unrollRecursionContexts(_parentctx);
+		}
+		return _localctx;
+	}
+
+	public static class CompilationUnitContext extends ParserRuleContext {
+		public TerminalNode EOF() { return getToken(DroppingJavaParser.EOF, 0); }
+		public PackageDeclarationContext packageDeclaration() {
+			return getRuleContext(PackageDeclarationContext.class,0);
+		}
+		public List<ImportDeclarationContext> importDeclaration() {
+			return getRuleContexts(ImportDeclarationContext.class);
+		}
+		public ImportDeclarationContext importDeclaration(int i) {
+			return getRuleContext(ImportDeclarationContext.class,i);
+		}
+		public List<TypeDeclarationContext> typeDeclaration() {
+			return getRuleContexts(TypeDeclarationContext.class);
+		}
+		public TypeDeclarationContext typeDeclaration(int i) {
+			return getRuleContext(TypeDeclarationContext.class,i);
+		}
+		public CompilationUnitContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_compilationUnit; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterCompilationUnit(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitCompilationUnit(this);
+		}
+	}
+
+	public final CompilationUnitContext compilationUnit() throws RecognitionException {
+		CompilationUnitContext _localctx = new CompilationUnitContext(_ctx, getState());
+		enterRule(_localctx, 56, RULE_compilationUnit);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(465);
+			switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
+			case 1:
+				{
+				setState(464);
+				packageDeclaration();
+				}
+				break;
+			}
+			setState(470);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==IMPORT) {
+				{
+				{
+				setState(467);
+				importDeclaration();
+				}
+				}
+				setState(472);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(476);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << CLASS) | (1L << ENUM) | (1L << FINAL) | (1L << INTERFACE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP) | (1L << SEMI))) != 0) || _la==AT) {
+				{
+				{
+				setState(473);
+				typeDeclaration();
+				}
+				}
+				setState(478);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(479);
+			match(EOF);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class PackageDeclarationContext extends ParserRuleContext {
+		public List<TerminalNode> Identifier() { return getTokens(DroppingJavaParser.Identifier); }
+		public TerminalNode Identifier(int i) {
+			return getToken(DroppingJavaParser.Identifier, i);
+		}
+		public List<PackageModifierContext> packageModifier() {
+			return getRuleContexts(PackageModifierContext.class);
+		}
+		public PackageModifierContext packageModifier(int i) {
+			return getRuleContext(PackageModifierContext.class,i);
+		}
+		public PackageDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_packageDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterPackageDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitPackageDeclaration(this);
+		}
+	}
+
+	public final PackageDeclarationContext packageDeclaration() throws RecognitionException {
+		PackageDeclarationContext _localctx = new PackageDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 58, RULE_packageDeclaration);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(484);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==AT) {
+				{
+				{
+				setState(481);
+				packageModifier();
+				}
+				}
+				setState(486);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(487);
+			match(PACKAGE);
+			setState(488);
+			match(Identifier);
+			setState(493);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==DOT) {
+				{
+				{
+				setState(489);
+				match(DOT);
+				setState(490);
+				match(Identifier);
+				}
+				}
+				setState(495);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(496);
+			match(SEMI);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class PackageModifierContext extends ParserRuleContext {
+		public AnnotationContext annotation() {
+			return getRuleContext(AnnotationContext.class,0);
+		}
+		public PackageModifierContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_packageModifier; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterPackageModifier(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitPackageModifier(this);
+		}
+	}
+
+	public final PackageModifierContext packageModifier() throws RecognitionException {
+		PackageModifierContext _localctx = new PackageModifierContext(_ctx, getState());
+		enterRule(_localctx, 60, RULE_packageModifier);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(498);
+			annotation();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ImportDeclarationContext extends ParserRuleContext {
+		public SingleTypeImportDeclarationContext singleTypeImportDeclaration() {
+			return getRuleContext(SingleTypeImportDeclarationContext.class,0);
+		}
+		public TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() {
+			return getRuleContext(TypeImportOnDemandDeclarationContext.class,0);
+		}
+		public SingleStaticImportDeclarationContext singleStaticImportDeclaration() {
+			return getRuleContext(SingleStaticImportDeclarationContext.class,0);
+		}
+		public StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() {
+			return getRuleContext(StaticImportOnDemandDeclarationContext.class,0);
+		}
+		public ImportDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_importDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterImportDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitImportDeclaration(this);
+		}
+	}
+
+	public final ImportDeclarationContext importDeclaration() throws RecognitionException {
+		ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 62, RULE_importDeclaration);
+		try {
+			setState(504);
+			switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(500);
+				singleTypeImportDeclaration();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(501);
+				typeImportOnDemandDeclaration();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(502);
+				singleStaticImportDeclaration();
+				}
+				break;
+			case 4:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(503);
+				staticImportOnDemandDeclaration();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class SingleTypeImportDeclarationContext extends ParserRuleContext {
+		public TypeNameContext typeName() {
+			return getRuleContext(TypeNameContext.class,0);
+		}
+		public SingleTypeImportDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_singleTypeImportDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterSingleTypeImportDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitSingleTypeImportDeclaration(this);
+		}
+	}
+
+	public final SingleTypeImportDeclarationContext singleTypeImportDeclaration() throws RecognitionException {
+		SingleTypeImportDeclarationContext _localctx = new SingleTypeImportDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 64, RULE_singleTypeImportDeclaration);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(506);
+			match(IMPORT);
+			setState(507);
+			typeName();
+			setState(508);
+			match(SEMI);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeImportOnDemandDeclarationContext extends ParserRuleContext {
+		public PackageOrTypeNameContext packageOrTypeName() {
+			return getRuleContext(PackageOrTypeNameContext.class,0);
+		}
+		public TypeImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeImportOnDemandDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterTypeImportOnDemandDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeImportOnDemandDeclaration(this);
+		}
+	}
+
+	public final TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() throws RecognitionException {
+		TypeImportOnDemandDeclarationContext _localctx = new TypeImportOnDemandDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 66, RULE_typeImportOnDemandDeclaration);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(510);
+			match(IMPORT);
+			setState(511);
+			packageOrTypeName(0);
+			setState(512);
+			match(DOT);
+			setState(513);
+			match(MUL);
+			setState(514);
+			match(SEMI);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class SingleStaticImportDeclarationContext extends ParserRuleContext {
+		public TypeNameContext typeName() {
+			return getRuleContext(TypeNameContext.class,0);
+		}
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public SingleStaticImportDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_singleStaticImportDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterSingleStaticImportDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitSingleStaticImportDeclaration(this);
+		}
+	}
+
+	public final SingleStaticImportDeclarationContext singleStaticImportDeclaration() throws RecognitionException {
+		SingleStaticImportDeclarationContext _localctx = new SingleStaticImportDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 68, RULE_singleStaticImportDeclaration);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(516);
+			match(IMPORT);
+			setState(517);
+			match(STATIC);
+			setState(518);
+			typeName();
+			setState(519);
+			match(DOT);
+			setState(520);
+			match(Identifier);
+			setState(521);
+			match(SEMI);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class StaticImportOnDemandDeclarationContext extends ParserRuleContext {
+		public TypeNameContext typeName() {
+			return getRuleContext(TypeNameContext.class,0);
+		}
+		public StaticImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_staticImportOnDemandDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterStaticImportOnDemandDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitStaticImportOnDemandDeclaration(this);
+		}
+	}
+
+	public final StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() throws RecognitionException {
+		StaticImportOnDemandDeclarationContext _localctx = new StaticImportOnDemandDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 70, RULE_staticImportOnDemandDeclaration);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(523);
+			match(IMPORT);
+			setState(524);
+			match(STATIC);
+			setState(525);
+			typeName();
+			setState(526);
+			match(DOT);
+			setState(527);
+			match(MUL);
+			setState(528);
+			match(SEMI);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeDeclarationContext extends ParserRuleContext {
+		public ClassDeclarationContext classDeclaration() {
+			return getRuleContext(ClassDeclarationContext.class,0);
+		}
+		public InterfaceDeclarationContext interfaceDeclaration() {
+			return getRuleContext(InterfaceDeclarationContext.class,0);
+		}
+		public TypeDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterTypeDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeDeclaration(this);
+		}
+	}
+
+	public final TypeDeclarationContext typeDeclaration() throws RecognitionException {
+		TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 72, RULE_typeDeclaration);
+		try {
+			setState(533);
+			switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(530);
+				classDeclaration();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(531);
+				interfaceDeclaration();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(532);
+				match(SEMI);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ClassDeclarationContext extends ParserRuleContext {
+		public NormalClassDeclarationContext normalClassDeclaration() {
+			return getRuleContext(NormalClassDeclarationContext.class,0);
+		}
+		public EnumDeclarationContext enumDeclaration() {
+			return getRuleContext(EnumDeclarationContext.class,0);
+		}
+		public ClassDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_classDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterClassDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassDeclaration(this);
+		}
+	}
+
+	public final ClassDeclarationContext classDeclaration() throws RecognitionException {
+		ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 74, RULE_classDeclaration);
+		try {
+			setState(537);
+			switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(535);
+				normalClassDeclaration();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(536);
+				enumDeclaration();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class NormalClassDeclarationContext extends ParserRuleContext {
+		public NormalClassDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_normalClassDeclaration; }
+	 
+		public NormalClassDeclarationContext() { }
+		public void copyFrom(NormalClassDeclarationContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class ClassNameContext extends NormalClassDeclarationContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public ClassBodyContext classBody() {
+			return getRuleContext(ClassBodyContext.class,0);
+		}
+		public List<ClassModifierContext> classModifier() {
+			return getRuleContexts(ClassModifierContext.class);
+		}
+		public ClassModifierContext classModifier(int i) {
+			return getRuleContext(ClassModifierContext.class,i);
+		}
+		public TypeParametersContext typeParameters() {
+			return getRuleContext(TypeParametersContext.class,0);
+		}
+		public SuperclassContext superclass() {
+			return getRuleContext(SuperclassContext.class,0);
+		}
+		public SuperinterfacesContext superinterfaces() {
+			return getRuleContext(SuperinterfacesContext.class,0);
+		}
+		public ClassNameContext(NormalClassDeclarationContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterClassName(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassName(this);
+		}
+	}
+
+	public final NormalClassDeclarationContext normalClassDeclaration() throws RecognitionException {
+		NormalClassDeclarationContext _localctx = new NormalClassDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 76, RULE_normalClassDeclaration);
+		int _la;
+		try {
+			_localctx = new ClassNameContext(_localctx);
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(542);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
+				{
+				{
+				setState(539);
+				classModifier();
+				}
+				}
+				setState(544);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(545);
+			match(CLASS);
+			setState(546);
+			match(Identifier);
+			setState(548);
+			_la = _input.LA(1);
+			if (_la==LT) {
+				{
+				setState(547);
+				typeParameters();
+				}
+			}
+
+			setState(551);
+			_la = _input.LA(1);
+			if (_la==EXTENDS) {
+				{
+				setState(550);
+				superclass();
+				}
+			}
+
+			setState(554);
+			_la = _input.LA(1);
+			if (_la==IMPLEMENTS) {
+				{
+				setState(553);
+				superinterfaces();
+				}
+			}
+
+			setState(556);
+			classBody();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ClassModifierContext extends ParserRuleContext {
+		public AnnotationContext annotation() {
+			return getRuleContext(AnnotationContext.class,0);
+		}
+		public ClassModifierContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_classModifier; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterClassModifier(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassModifier(this);
+		}
+	}
+
+	public final ClassModifierContext classModifier() throws RecognitionException {
+		ClassModifierContext _localctx = new ClassModifierContext(_ctx, getState());
+		enterRule(_localctx, 78, RULE_classModifier);
+		try {
+			setState(566);
+			switch (_input.LA(1)) {
+			case AT:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(558);
+				annotation();
+				}
+				break;
+			case PUBLIC:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(559);
+				match(PUBLIC);
+				}
+				break;
+			case PROTECTED:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(560);
+				match(PROTECTED);
+				}
+				break;
+			case PRIVATE:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(561);
+				match(PRIVATE);
+				}
+				break;
+			case ABSTRACT:
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(562);
+				match(ABSTRACT);
+				}
+				break;
+			case STATIC:
+				enterOuterAlt(_localctx, 6);
+				{
+				setState(563);
+				match(STATIC);
+				}
+				break;
+			case FINAL:
+				enterOuterAlt(_localctx, 7);
+				{
+				setState(564);
+				match(FINAL);
+				}
+				break;
+			case STRICTFP:
+				enterOuterAlt(_localctx, 8);
+				{
+				setState(565);
+				match(STRICTFP);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeParametersContext extends ParserRuleContext {
+		public TypeParameterListContext typeParameterList() {
+			return getRuleContext(TypeParameterListContext.class,0);
+		}
+		public TypeParametersContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeParameters; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterTypeParameters(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeParameters(this);
+		}
+	}
+
+	public final TypeParametersContext typeParameters() throws RecognitionException {
+		TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState());
+		enterRule(_localctx, 80, RULE_typeParameters);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(568);
+			match(LT);
+			setState(569);
+			typeParameterList();
+			setState(570);
+			match(GT);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeParameterListContext extends ParserRuleContext {
+		public List<TypeParameterContext> typeParameter() {
+			return getRuleContexts(TypeParameterContext.class);
+		}
+		public TypeParameterContext typeParameter(int i) {
+			return getRuleContext(TypeParameterContext.class,i);
+		}
+		public TypeParameterListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeParameterList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterTypeParameterList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeParameterList(this);
+		}
+	}
+
+	public final TypeParameterListContext typeParameterList() throws RecognitionException {
+		TypeParameterListContext _localctx = new TypeParameterListContext(_ctx, getState());
+		enterRule(_localctx, 82, RULE_typeParameterList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(572);
+			typeParameter();
+			setState(577);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==COMMA) {
+				{
+				{
+				setState(573);
+				match(COMMA);
+				setState(574);
+				typeParameter();
+				}
+				}
+				setState(579);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class SuperclassContext extends ParserRuleContext {
+		public ClassTypeContext classType() {
+			return getRuleContext(ClassTypeContext.class,0);
+		}
+		public SuperclassContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_superclass; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterSuperclass(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitSuperclass(this);
+		}
+	}
+
+	public final SuperclassContext superclass() throws RecognitionException {
+		SuperclassContext _localctx = new SuperclassContext(_ctx, getState());
+		enterRule(_localctx, 84, RULE_superclass);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(580);
+			match(EXTENDS);
+			setState(581);
+			classType();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class SuperinterfacesContext extends ParserRuleContext {
+		public InterfaceTypeListContext interfaceTypeList() {
+			return getRuleContext(InterfaceTypeListContext.class,0);
+		}
+		public SuperinterfacesContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_superinterfaces; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterSuperinterfaces(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitSuperinterfaces(this);
+		}
+	}
+
+	public final SuperinterfacesContext superinterfaces() throws RecognitionException {
+		SuperinterfacesContext _localctx = new SuperinterfacesContext(_ctx, getState());
+		enterRule(_localctx, 86, RULE_superinterfaces);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(583);
+			match(IMPLEMENTS);
+			setState(584);
+			interfaceTypeList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InterfaceTypeListContext extends ParserRuleContext {
+		public List<InterfaceTypeContext> interfaceType() {
+			return getRuleContexts(InterfaceTypeContext.class);
+		}
+		public InterfaceTypeContext interfaceType(int i) {
+			return getRuleContext(InterfaceTypeContext.class,i);
+		}
+		public InterfaceTypeListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_interfaceTypeList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterInterfaceTypeList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceTypeList(this);
+		}
+	}
+
+	public final InterfaceTypeListContext interfaceTypeList() throws RecognitionException {
+		InterfaceTypeListContext _localctx = new InterfaceTypeListContext(_ctx, getState());
+		enterRule(_localctx, 88, RULE_interfaceTypeList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(586);
+			interfaceType();
+			setState(591);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==COMMA) {
+				{
+				{
+				setState(587);
+				match(COMMA);
+				setState(588);
+				interfaceType();
+				}
+				}
+				setState(593);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ClassBodyContext extends ParserRuleContext {
+		public List<ClassBodyDeclarationContext> classBodyDeclaration() {
+			return getRuleContexts(ClassBodyDeclarationContext.class);
+		}
+		public ClassBodyDeclarationContext classBodyDeclaration(int i) {
+			return getRuleContext(ClassBodyDeclarationContext.class,i);
+		}
+		public ClassBodyContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_classBody; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterClassBody(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassBody(this);
+		}
+	}
+
+	public final ClassBodyContext classBody() throws RecognitionException {
+		ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState());
+		enterRule(_localctx, 90, RULE_classBody);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(594);
+			match(LBRACE);
+			setState(598);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,50,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(595);
+					classBodyDeclaration();
+					}
+					} 
+				}
+				setState(600);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,50,_ctx);
+			}
+			setState(601);
+			match(RBRACE);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ClassBodyDeclarationContext extends ParserRuleContext {
+		public ClassMemberDeclarationContext classMemberDeclaration() {
+			return getRuleContext(ClassMemberDeclarationContext.class,0);
+		}
+		public InstanceInitializerContext instanceInitializer() {
+			return getRuleContext(InstanceInitializerContext.class,0);
+		}
+		public StaticInitializerContext staticInitializer() {
+			return getRuleContext(StaticInitializerContext.class,0);
+		}
+		public ConstructorDeclarationContext constructorDeclaration() {
+			return getRuleContext(ConstructorDeclarationContext.class,0);
+		}
+		public ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_classBodyDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterClassBodyDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassBodyDeclaration(this);
+		}
+	}
+
+	public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException {
+		ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 92, RULE_classBodyDeclaration);
+		try {
+			setState(607);
+			switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(603);
+				classMemberDeclaration();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(604);
+				instanceInitializer();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(605);
+				staticInitializer();
+				}
+				break;
+			case 4:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(606);
+				constructorDeclaration();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ClassMemberDeclarationContext extends ParserRuleContext {
+		public FieldDeclarationContext fieldDeclaration() {
+			return getRuleContext(FieldDeclarationContext.class,0);
+		}
+		public MethodDeclarationContext methodDeclaration() {
+			return getRuleContext(MethodDeclarationContext.class,0);
+		}
+		public ClassDeclarationContext classDeclaration() {
+			return getRuleContext(ClassDeclarationContext.class,0);
+		}
+		public InterfaceDeclarationContext interfaceDeclaration() {
+			return getRuleContext(InterfaceDeclarationContext.class,0);
+		}
+		public ClassMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_classMemberDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterClassMemberDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassMemberDeclaration(this);
+		}
+	}
+
+	public final ClassMemberDeclarationContext classMemberDeclaration() throws RecognitionException {
+		ClassMemberDeclarationContext _localctx = new ClassMemberDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 94, RULE_classMemberDeclaration);
+		try {
+			setState(614);
+			switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(609);
+				fieldDeclaration();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(610);
+				methodDeclaration();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(611);
+				classDeclaration();
+				}
+				break;
+			case 4:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(612);
+				interfaceDeclaration();
+				}
+				break;
+			case 5:
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(613);
+				match(SEMI);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class FieldDeclarationContext extends ParserRuleContext {
+		public FieldDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_fieldDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterFieldDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitFieldDeclaration(this);
+		}
+	}
+
+	public final FieldDeclarationContext fieldDeclaration() throws RecognitionException {
+		FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 96, RULE_fieldDeclaration);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(617); 
+			_errHandler.sync(this);
+			_alt = 1+1;
+			do {
+				switch (_alt) {
+				case 1+1:
+					{
+					{
+					setState(616);
+					matchWildcard();
+					}
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				setState(619); 
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,53,_ctx);
+			} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+			setState(621);
+			match(SEMI);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class VariableDeclaratorIdContext extends ParserRuleContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public DimsContext dims() {
+			return getRuleContext(DimsContext.class,0);
+		}
+		public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_variableDeclaratorId; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterVariableDeclaratorId(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitVariableDeclaratorId(this);
+		}
+	}
+
+	public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException {
+		VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState());
+		enterRule(_localctx, 98, RULE_variableDeclaratorId);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(623);
+			match(Identifier);
+			setState(625);
+			_la = _input.LA(1);
+			if (_la==LBRACK || _la==AT) {
+				{
+				setState(624);
+				dims();
+				}
+			}
+
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class VariableInitializerContext extends ParserRuleContext {
+		public ExpressionContext expression() {
+			return getRuleContext(ExpressionContext.class,0);
+		}
+		public ArrayInitializerContext arrayInitializer() {
+			return getRuleContext(ArrayInitializerContext.class,0);
+		}
+		public VariableInitializerContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_variableInitializer; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterVariableInitializer(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitVariableInitializer(this);
+		}
+	}
+
+	public final VariableInitializerContext variableInitializer() throws RecognitionException {
+		VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState());
+		enterRule(_localctx, 100, RULE_variableInitializer);
+		try {
+			setState(629);
+			switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(627);
+				expression();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(628);
+				arrayInitializer();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class UnannTypeContext extends ParserRuleContext {
+		public UnannPrimitiveTypeContext unannPrimitiveType() {
+			return getRuleContext(UnannPrimitiveTypeContext.class,0);
+		}
+		public UnannReferenceTypeContext unannReferenceType() {
+			return getRuleContext(UnannReferenceTypeContext.class,0);
+		}
+		public UnannTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_unannType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterUnannType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannType(this);
+		}
+	}
+
+	public final UnannTypeContext unannType() throws RecognitionException {
+		UnannTypeContext _localctx = new UnannTypeContext(_ctx, getState());
+		enterRule(_localctx, 102, RULE_unannType);
+		try {
+			setState(633);
+			switch ( getInterpreter().adaptivePredict(_input,56,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(631);
+				unannPrimitiveType();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(632);
+				unannReferenceType();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class UnannPrimitiveTypeContext extends ParserRuleContext {
+		public NumericTypeContext numericType() {
+			return getRuleContext(NumericTypeContext.class,0);
+		}
+		public UnannPrimitiveTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_unannPrimitiveType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterUnannPrimitiveType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannPrimitiveType(this);
+		}
+	}
+
+	public final UnannPrimitiveTypeContext unannPrimitiveType() throws RecognitionException {
+		UnannPrimitiveTypeContext _localctx = new UnannPrimitiveTypeContext(_ctx, getState());
+		enterRule(_localctx, 104, RULE_unannPrimitiveType);
+		try {
+			setState(637);
+			switch (_input.LA(1)) {
+			case BYTE:
+			case CHAR:
+			case DOUBLE:
+			case FLOAT:
+			case INT:
+			case LONG:
+			case SHORT:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(635);
+				numericType();
+				}
+				break;
+			case BOOLEAN:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(636);
+				match(BOOLEAN);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class UnannReferenceTypeContext extends ParserRuleContext {
+		public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() {
+			return getRuleContext(UnannClassOrInterfaceTypeContext.class,0);
+		}
+		public UnannTypeVariableContext unannTypeVariable() {
+			return getRuleContext(UnannTypeVariableContext.class,0);
+		}
+		public UnannArrayTypeContext unannArrayType() {
+			return getRuleContext(UnannArrayTypeContext.class,0);
+		}
+		public UnannReferenceTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_unannReferenceType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterUnannReferenceType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannReferenceType(this);
+		}
+	}
+
+	public final UnannReferenceTypeContext unannReferenceType() throws RecognitionException {
+		UnannReferenceTypeContext _localctx = new UnannReferenceTypeContext(_ctx, getState());
+		enterRule(_localctx, 106, RULE_unannReferenceType);
+		try {
+			setState(642);
+			switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(639);
+				unannClassOrInterfaceType();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(640);
+				unannTypeVariable();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(641);
+				unannArrayType();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class UnannClassOrInterfaceTypeContext extends ParserRuleContext {
+		public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() {
+			return getRuleContext(UnannClassType_lfno_unannClassOrInterfaceTypeContext.class,0);
+		}
+		public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() {
+			return getRuleContext(UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext.class,0);
+		}
+		public List<UnannClassType_lf_unannClassOrInterfaceTypeContext> unannClassType_lf_unannClassOrInterfaceType() {
+			return getRuleContexts(UnannClassType_lf_unannClassOrInterfaceTypeContext.class);
+		}
+		public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType(int i) {
+			return getRuleContext(UnannClassType_lf_unannClassOrInterfaceTypeContext.class,i);
+		}
+		public List<UnannInterfaceType_lf_unannClassOrInterfaceTypeContext> unannInterfaceType_lf_unannClassOrInterfaceType() {
+			return getRuleContexts(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext.class);
+		}
+		public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType(int i) {
+			return getRuleContext(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext.class,i);
+		}
+		public UnannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_unannClassOrInterfaceType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterUnannClassOrInterfaceType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannClassOrInterfaceType(this);
+		}
+	}
+
+	public final UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() throws RecognitionException {
+		UnannClassOrInterfaceTypeContext _localctx = new UnannClassOrInterfaceTypeContext(_ctx, getState());
+		enterRule(_localctx, 108, RULE_unannClassOrInterfaceType);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(646);
+			switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
+			case 1:
+				{
+				setState(644);
+				unannClassType_lfno_unannClassOrInterfaceType();
+				}
+				break;
+			case 2:
+				{
+				setState(645);
+				unannInterfaceType_lfno_unannClassOrInterfaceType();
+				}
+				break;
+			}
+			setState(652);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,61,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					setState(650);
+					switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
+					case 1:
+						{
+						setState(648);
+						unannClassType_lf_unannClassOrInterfaceType();
+						}
+						break;
+					case 2:
+						{
+						setState(649);
+						unannInterfaceType_lf_unannClassOrInterfaceType();
+						}
+						break;
+					}
+					} 
+				}
+				setState(654);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,61,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class UnannClassType_lf_unannClassOrInterfaceTypeContext extends ParserRuleContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public List<AnnotationContext> annotation() {
+			return getRuleContexts(AnnotationContext.class);
+		}
+		public AnnotationContext annotation(int i) {
+			return getRuleContext(AnnotationContext.class,i);
+		}
+		public TypeArgumentsContext typeArguments() {
+			return getRuleContext(TypeArgumentsContext.class,0);
+		}
+		public UnannClassType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_unannClassType_lf_unannClassOrInterfaceType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterUnannClassType_lf_unannClassOrInterfaceType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannClassType_lf_unannClassOrInterfaceType(this);
+		}
+	}
+
+	public final UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() throws RecognitionException {
+		UnannClassType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lf_unannClassOrInterfaceTypeContext(_ctx, getState());
+		enterRule(_localctx, 110, RULE_unannClassType_lf_unannClassOrInterfaceType);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(655);
+			match(DOT);
+			setState(659);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==AT) {
+				{
+				{
+				setState(656);
+				annotation();
+				}
+				}
+				setState(661);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(662);
+			match(Identifier);
+			setState(664);
+			switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) {
+			case 1:
+				{
+				setState(663);
+				typeArguments();
+				}
+				break;
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class UnannClassType_lfno_unannClassOrInterfaceTypeContext extends ParserRuleContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public TypeArgumentsContext typeArguments() {
+			return getRuleContext(TypeArgumentsContext.class,0);
+		}
+		public UnannClassType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_unannClassType_lfno_unannClassOrInterfaceType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterUnannClassType_lfno_unannClassOrInterfaceType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannClassType_lfno_unannClassOrInterfaceType(this);
+		}
+	}
+
+	public final UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() throws RecognitionException {
+		UnannClassType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState());
+		enterRule(_localctx, 112, RULE_unannClassType_lfno_unannClassOrInterfaceType);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(666);
+			match(Identifier);
+			setState(668);
+			switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
+			case 1:
+				{
+				setState(667);
+				typeArguments();
+				}
+				break;
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class UnannInterfaceType_lf_unannClassOrInterfaceTypeContext extends ParserRuleContext {
+		public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() {
+			return getRuleContext(UnannClassType_lf_unannClassOrInterfaceTypeContext.class,0);
+		}
+		public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_unannInterfaceType_lf_unannClassOrInterfaceType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterUnannInterfaceType_lf_unannClassOrInterfaceType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannInterfaceType_lf_unannClassOrInterfaceType(this);
+		}
+	}
+
+	public final UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType() throws RecognitionException {
+		UnannInterfaceType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(_ctx, getState());
+		enterRule(_localctx, 114, RULE_unannInterfaceType_lf_unannClassOrInterfaceType);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(670);
+			unannClassType_lf_unannClassOrInterfaceType();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext extends ParserRuleContext {
+		public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() {
+			return getRuleContext(UnannClassType_lfno_unannClassOrInterfaceTypeContext.class,0);
+		}
+		public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_unannInterfaceType_lfno_unannClassOrInterfaceType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterUnannInterfaceType_lfno_unannClassOrInterfaceType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannInterfaceType_lfno_unannClassOrInterfaceType(this);
+		}
+	}
+
+	public final UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() throws RecognitionException {
+		UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState());
+		enterRule(_localctx, 116, RULE_unannInterfaceType_lfno_unannClassOrInterfaceType);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(672);
+			unannClassType_lfno_unannClassOrInterfaceType();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class UnannTypeVariableContext extends ParserRuleContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public UnannTypeVariableContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_unannTypeVariable; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterUnannTypeVariable(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannTypeVariable(this);
+		}
+	}
+
+	public final UnannTypeVariableContext unannTypeVariable() throws RecognitionException {
+		UnannTypeVariableContext _localctx = new UnannTypeVariableContext(_ctx, getState());
+		enterRule(_localctx, 118, RULE_unannTypeVariable);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(674);
+			match(Identifier);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class UnannArrayTypeContext extends ParserRuleContext {
+		public UnannPrimitiveTypeContext unannPrimitiveType() {
+			return getRuleContext(UnannPrimitiveTypeContext.class,0);
+		}
+		public DimsContext dims() {
+			return getRuleContext(DimsContext.class,0);
+		}
+		public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() {
+			return getRuleContext(UnannClassOrInterfaceTypeContext.class,0);
+		}
+		public UnannTypeVariableContext unannTypeVariable() {
+			return getRuleContext(UnannTypeVariableContext.class,0);
+		}
+		public UnannArrayTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_unannArrayType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterUnannArrayType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannArrayType(this);
+		}
+	}
+
+	public final UnannArrayTypeContext unannArrayType() throws RecognitionException {
+		UnannArrayTypeContext _localctx = new UnannArrayTypeContext(_ctx, getState());
+		enterRule(_localctx, 120, RULE_unannArrayType);
+		try {
+			setState(685);
+			switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(676);
+				unannPrimitiveType();
+				setState(677);
+				dims();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(679);
+				unannClassOrInterfaceType();
+				setState(680);
+				dims();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(682);
+				unannTypeVariable();
+				setState(683);
+				dims();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class MethodDeclarationContext extends ParserRuleContext {
+		public MethodHeaderContext methodHeader() {
+			return getRuleContext(MethodHeaderContext.class,0);
+		}
+		public MethodBodyContext methodBody() {
+			return getRuleContext(MethodBodyContext.class,0);
+		}
+		public List<MethodModifierContext> methodModifier() {
+			return getRuleContexts(MethodModifierContext.class);
+		}
+		public MethodModifierContext methodModifier(int i) {
+			return getRuleContext(MethodModifierContext.class,i);
+		}
+		public MethodDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_methodDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterMethodDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitMethodDeclaration(this);
+		}
+	}
+
+	public final MethodDeclarationContext methodDeclaration() throws RecognitionException {
+		MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 122, RULE_methodDeclaration);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(690);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED))) != 0) || _la==AT) {
+				{
+				{
+				setState(687);
+				methodModifier();
+				}
+				}
+				setState(692);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(693);
+			methodHeader();
+			setState(694);
+			methodBody();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class MethodModifierContext extends ParserRuleContext {
+		public AnnotationContext annotation() {
+			return getRuleContext(AnnotationContext.class,0);
+		}
+		public MethodModifierContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_methodModifier; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterMethodModifier(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitMethodModifier(this);
+		}
+	}
+
+	public final MethodModifierContext methodModifier() throws RecognitionException {
+		MethodModifierContext _localctx = new MethodModifierContext(_ctx, getState());
+		enterRule(_localctx, 124, RULE_methodModifier);
+		try {
+			setState(706);
+			switch (_input.LA(1)) {
+			case AT:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(696);
+				annotation();
+				}
+				break;
+			case PUBLIC:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(697);
+				match(PUBLIC);
+				}
+				break;
+			case PROTECTED:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(698);
+				match(PROTECTED);
+				}
+				break;
+			case PRIVATE:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(699);
+				match(PRIVATE);
+				}
+				break;
+			case ABSTRACT:
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(700);
+				match(ABSTRACT);
+				}
+				break;
+			case STATIC:
+				enterOuterAlt(_localctx, 6);
+				{
+				setState(701);
+				match(STATIC);
+				}
+				break;
+			case FINAL:
+				enterOuterAlt(_localctx, 7);
+				{
+				setState(702);
+				match(FINAL);
+				}
+				break;
+			case SYNCHRONIZED:
+				enterOuterAlt(_localctx, 8);
+				{
+				setState(703);
+				match(SYNCHRONIZED);
+				}
+				break;
+			case NATIVE:
+				enterOuterAlt(_localctx, 9);
+				{
+				setState(704);
+				match(NATIVE);
+				}
+				break;
+			case STRICTFP:
+				enterOuterAlt(_localctx, 10);
+				{
+				setState(705);
+				match(STRICTFP);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class MethodHeaderContext extends ParserRuleContext {
+		public ResultContext result() {
+			return getRuleContext(ResultContext.class,0);
+		}
+		public MethodDeclaratorContext methodDeclarator() {
+			return getRuleContext(MethodDeclaratorContext.class,0);
+		}
+		public Throws_Context throws_() {
+			return getRuleContext(Throws_Context.class,0);
+		}
+		public TypeParametersContext typeParameters() {
+			return getRuleContext(TypeParametersContext.class,0);
+		}
+		public List<AnnotationContext> annotation() {
+			return getRuleContexts(AnnotationContext.class);
+		}
+		public AnnotationContext annotation(int i) {
+			return getRuleContext(AnnotationContext.class,i);
+		}
+		public MethodHeaderContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_methodHeader; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterMethodHeader(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitMethodHeader(this);
+		}
+	}
+
+	public final MethodHeaderContext methodHeader() throws RecognitionException {
+		MethodHeaderContext _localctx = new MethodHeaderContext(_ctx, getState());
+		enterRule(_localctx, 126, RULE_methodHeader);
+		int _la;
+		try {
+			setState(725);
+			switch (_input.LA(1)) {
+			case BOOLEAN:
+			case BYTE:
+			case CHAR:
+			case DOUBLE:
+			case FLOAT:
+			case INT:
+			case LONG:
+			case SHORT:
+			case VOID:
+			case Identifier:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(708);
+				result();
+				setState(709);
+				methodDeclarator();
+				setState(711);
+				_la = _input.LA(1);
+				if (_la==THROWS) {
+					{
+					setState(710);
+					throws_();
+					}
+				}
+
+				}
+				break;
+			case LT:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(713);
+				typeParameters();
+				setState(717);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==AT) {
+					{
+					{
+					setState(714);
+					annotation();
+					}
+					}
+					setState(719);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(720);
+				result();
+				setState(721);
+				methodDeclarator();
+				setState(723);
+				_la = _input.LA(1);
+				if (_la==THROWS) {
+					{
+					setState(722);
+					throws_();
+					}
+				}
+
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ResultContext extends ParserRuleContext {
+		public UnannTypeContext unannType() {
+			return getRuleContext(UnannTypeContext.class,0);
+		}
+		public ResultContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_result; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterResult(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitResult(this);
+		}
+	}
+
+	public final ResultContext result() throws RecognitionException {
+		ResultContext _localctx = new ResultContext(_ctx, getState());
+		enterRule(_localctx, 128, RULE_result);
+		try {
+			setState(729);
+			switch (_input.LA(1)) {
+			case BOOLEAN:
+			case BYTE:
+			case CHAR:
+			case DOUBLE:
+			case FLOAT:
+			case INT:
+			case LONG:
+			case SHORT:
+			case Identifier:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(727);
+				unannType();
+				}
+				break;
+			case VOID:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(728);
+				match(VOID);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class MethodDeclaratorContext extends ParserRuleContext {
+		public MethodDeclaratorContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_methodDeclarator; }
+	 
+		public MethodDeclaratorContext() { }
+		public void copyFrom(MethodDeclaratorContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class MethodNameContext extends MethodDeclaratorContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public FormalParameterListContext formalParameterList() {
+			return getRuleContext(FormalParameterListContext.class,0);
+		}
+		public DimsContext dims() {
+			return getRuleContext(DimsContext.class,0);
+		}
+		public MethodNameContext(MethodDeclaratorContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterMethodName(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitMethodName(this);
+		}
+	}
+
+	public final MethodDeclaratorContext methodDeclarator() throws RecognitionException {
+		MethodDeclaratorContext _localctx = new MethodDeclaratorContext(_ctx, getState());
+		enterRule(_localctx, 130, RULE_methodDeclarator);
+		int _la;
+		try {
+			_localctx = new MethodNameContext(_localctx);
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(731);
+			match(Identifier);
+			setState(732);
+			match(LPAREN);
+			setState(734);
+			_la = _input.LA(1);
+			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==Identifier || _la==AT) {
+				{
+				setState(733);
+				formalParameterList();
+				}
+			}
+
+			setState(736);
+			match(RPAREN);
+			setState(738);
+			_la = _input.LA(1);
+			if (_la==LBRACK || _la==AT) {
+				{
+				setState(737);
+				dims();
+				}
+			}
+
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class FormalParameterListContext extends ParserRuleContext {
+		public FormalParametersContext formalParameters() {
+			return getRuleContext(FormalParametersContext.class,0);
+		}
+		public LastFormalParameterContext lastFormalParameter() {
+			return getRuleContext(LastFormalParameterContext.class,0);
+		}
+		public FormalParameterListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_formalParameterList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterFormalParameterList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitFormalParameterList(this);
+		}
+	}
+
+	public final FormalParameterListContext formalParameterList() throws RecognitionException {
+		FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState());
+		enterRule(_localctx, 132, RULE_formalParameterList);
+		try {
+			setState(745);
+			switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(740);
+				formalParameters();
+				setState(741);
+				match(COMMA);
+				setState(742);
+				lastFormalParameter();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(744);
+				lastFormalParameter();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class FormalParametersContext extends ParserRuleContext {
+		public List<FormalParameterContext> formalParameter() {
+			return getRuleContexts(FormalParameterContext.class);
+		}
+		public FormalParameterContext formalParameter(int i) {
+			return getRuleContext(FormalParameterContext.class,i);
+		}
+		public ReceiverParameterContext receiverParameter() {
+			return getRuleContext(ReceiverParameterContext.class,0);
+		}
+		public FormalParametersContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_formalParameters; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterFormalParameters(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitFormalParameters(this);
+		}
+	}
+
+	public final FormalParametersContext formalParameters() throws RecognitionException {
+		FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState());
+		enterRule(_localctx, 134, RULE_formalParameters);
+		try {
+			int _alt;
+			setState(763);
+			switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(747);
+				formalParameter();
+				setState(752);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,76,_ctx);
+				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+					if ( _alt==1 ) {
+						{
+						{
+						setState(748);
+						match(COMMA);
+						setState(749);
+						formalParameter();
+						}
+						} 
+					}
+					setState(754);
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,76,_ctx);
+				}
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(755);
+				receiverParameter();
+				setState(760);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,77,_ctx);
+				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+					if ( _alt==1 ) {
+						{
+						{
+						setState(756);
+						match(COMMA);
+						setState(757);
+						formalParameter();
+						}
+						} 
+					}
+					setState(762);
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,77,_ctx);
+				}
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class FormalParameterContext extends ParserRuleContext {
+		public UnannTypeContext unannType() {
+			return getRuleContext(UnannTypeContext.class,0);
+		}
+		public VariableDeclaratorIdContext variableDeclaratorId() {
+			return getRuleContext(VariableDeclaratorIdContext.class,0);
+		}
+		public List<VariableModifierContext> variableModifier() {
+			return getRuleContexts(VariableModifierContext.class);
+		}
+		public VariableModifierContext variableModifier(int i) {
+			return getRuleContext(VariableModifierContext.class,i);
+		}
+		public FormalParameterContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_formalParameter; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterFormalParameter(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitFormalParameter(this);
+		}
+	}
+
+	public final FormalParameterContext formalParameter() throws RecognitionException {
+		FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState());
+		enterRule(_localctx, 136, RULE_formalParameter);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(768);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==FINAL || _la==AT) {
+				{
+				{
+				setState(765);
+				variableModifier();
+				}
+				}
+				setState(770);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(771);
+			unannType();
+			setState(772);
+			variableDeclaratorId();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class VariableModifierContext extends ParserRuleContext {
+		public AnnotationContext annotation() {
+			return getRuleContext(AnnotationContext.class,0);
+		}
+		public VariableModifierContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_variableModifier; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterVariableModifier(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitVariableModifier(this);
+		}
+	}
+
+	public final VariableModifierContext variableModifier() throws RecognitionException {
+		VariableModifierContext _localctx = new VariableModifierContext(_ctx, getState());
+		enterRule(_localctx, 138, RULE_variableModifier);
+		try {
+			setState(776);
+			switch (_input.LA(1)) {
+			case AT:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(774);
+				annotation();
+				}
+				break;
+			case FINAL:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(775);
+				match(FINAL);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class LastFormalParameterContext extends ParserRuleContext {
+		public UnannTypeContext unannType() {
+			return getRuleContext(UnannTypeContext.class,0);
+		}
+		public VariableDeclaratorIdContext variableDeclaratorId() {
+			return getRuleContext(VariableDeclaratorIdContext.class,0);
+		}
+		public List<VariableModifierContext> variableModifier() {
+			return getRuleContexts(VariableModifierContext.class);
+		}
+		public VariableModifierContext variableModifier(int i) {
+			return getRuleContext(VariableModifierContext.class,i);
+		}
+		public List<AnnotationContext> annotation() {
+			return getRuleContexts(AnnotationContext.class);
+		}
+		public AnnotationContext annotation(int i) {
+			return getRuleContext(AnnotationContext.class,i);
+		}
+		public FormalParameterContext formalParameter() {
+			return getRuleContext(FormalParameterContext.class,0);
+		}
+		public LastFormalParameterContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_lastFormalParameter; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterLastFormalParameter(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitLastFormalParameter(this);
+		}
+	}
+
+	public final LastFormalParameterContext lastFormalParameter() throws RecognitionException {
+		LastFormalParameterContext _localctx = new LastFormalParameterContext(_ctx, getState());
+		enterRule(_localctx, 140, RULE_lastFormalParameter);
+		int _la;
+		try {
+			setState(795);
+			switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(781);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==FINAL || _la==AT) {
+					{
+					{
+					setState(778);
+					variableModifier();
+					}
+					}
+					setState(783);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(784);
+				unannType();
+				setState(788);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==AT) {
+					{
+					{
+					setState(785);
+					annotation();
+					}
+					}
+					setState(790);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(791);
+				match(ELLIPSIS);
+				setState(792);
+				variableDeclaratorId();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(794);
+				formalParameter();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ReceiverParameterContext extends ParserRuleContext {
+		public UnannTypeContext unannType() {
+			return getRuleContext(UnannTypeContext.class,0);
+		}
+		public List<AnnotationContext> annotation() {
+			return getRuleContexts(AnnotationContext.class);
+		}
+		public AnnotationContext annotation(int i) {
+			return getRuleContext(AnnotationContext.class,i);
+		}
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public ReceiverParameterContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_receiverParameter; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterReceiverParameter(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitReceiverParameter(this);
+		}
+	}
+
+	public final ReceiverParameterContext receiverParameter() throws RecognitionException {
+		ReceiverParameterContext _localctx = new ReceiverParameterContext(_ctx, getState());
+		enterRule(_localctx, 142, RULE_receiverParameter);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(800);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==AT) {
+				{
+				{
+				setState(797);
+				annotation();
+				}
+				}
+				setState(802);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(803);
+			unannType();
+			setState(806);
+			_la = _input.LA(1);
+			if (_la==Identifier) {
+				{
+				setState(804);
+				match(Identifier);
+				setState(805);
+				match(DOT);
+				}
+			}
+
+			setState(808);
+			match(THIS);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class Throws_Context extends ParserRuleContext {
+		public ExceptionTypeListContext exceptionTypeList() {
+			return getRuleContext(ExceptionTypeListContext.class,0);
+		}
+		public Throws_Context(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_throws_; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterThrows_(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitThrows_(this);
+		}
+	}
+
+	public final Throws_Context throws_() throws RecognitionException {
+		Throws_Context _localctx = new Throws_Context(_ctx, getState());
+		enterRule(_localctx, 144, RULE_throws_);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(810);
+			match(THROWS);
+			setState(811);
+			exceptionTypeList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ExceptionTypeListContext extends ParserRuleContext {
+		public List<ExceptionTypeContext> exceptionType() {
+			return getRuleContexts(ExceptionTypeContext.class);
+		}
+		public ExceptionTypeContext exceptionType(int i) {
+			return getRuleContext(ExceptionTypeContext.class,i);
+		}
+		public ExceptionTypeListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_exceptionTypeList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterExceptionTypeList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitExceptionTypeList(this);
+		}
+	}
+
+	public final ExceptionTypeListContext exceptionTypeList() throws RecognitionException {
+		ExceptionTypeListContext _localctx = new ExceptionTypeListContext(_ctx, getState());
+		enterRule(_localctx, 146, RULE_exceptionTypeList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(813);
+			exceptionType();
+			setState(818);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==COMMA) {
+				{
+				{
+				setState(814);
+				match(COMMA);
+				setState(815);
+				exceptionType();
+				}
+				}
+				setState(820);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ExceptionTypeContext extends ParserRuleContext {
+		public ClassTypeContext classType() {
+			return getRuleContext(ClassTypeContext.class,0);
+		}
+		public TypeVariableContext typeVariable() {
+			return getRuleContext(TypeVariableContext.class,0);
+		}
+		public ExceptionTypeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_exceptionType; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterExceptionType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitExceptionType(this);
+		}
+	}
+
+	public final ExceptionTypeContext exceptionType() throws RecognitionException {
+		ExceptionTypeContext _localctx = new ExceptionTypeContext(_ctx, getState());
+		enterRule(_localctx, 148, RULE_exceptionType);
+		try {
+			setState(823);
+			switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(821);
+				classType();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(822);
+				typeVariable();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class MethodBodyContext extends ParserRuleContext {
+		public BlockContext block() {
+			return getRuleContext(BlockContext.class,0);
+		}
+		public MethodBodyContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_methodBody; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterMethodBody(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitMethodBody(this);
+		}
+	}
+
+	public final MethodBodyContext methodBody() throws RecognitionException {
+		MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState());
+		enterRule(_localctx, 150, RULE_methodBody);
+		try {
+			setState(827);
+			switch (_input.LA(1)) {
+			case LBRACE:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(825);
+				block();
+				}
+				break;
+			case SEMI:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(826);
+				match(SEMI);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InstanceInitializerContext extends ParserRuleContext {
+		public BlockContext block() {
+			return getRuleContext(BlockContext.class,0);
+		}
+		public InstanceInitializerContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_instanceInitializer; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterInstanceInitializer(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInstanceInitializer(this);
+		}
+	}
+
+	public final InstanceInitializerContext instanceInitializer() throws RecognitionException {
+		InstanceInitializerContext _localctx = new InstanceInitializerContext(_ctx, getState());
+		enterRule(_localctx, 152, RULE_instanceInitializer);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(829);
+			block();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class StaticInitializerContext extends ParserRuleContext {
+		public BlockContext block() {
+			return getRuleContext(BlockContext.class,0);
+		}
+		public StaticInitializerContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_staticInitializer; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterStaticInitializer(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitStaticInitializer(this);
+		}
+	}
+
+	public final StaticInitializerContext staticInitializer() throws RecognitionException {
+		StaticInitializerContext _localctx = new StaticInitializerContext(_ctx, getState());
+		enterRule(_localctx, 154, RULE_staticInitializer);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(831);
+			match(STATIC);
+			setState(832);
+			block();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ConstructorDeclarationContext extends ParserRuleContext {
+		public ConstructorDeclaratorContext constructorDeclarator() {
+			return getRuleContext(ConstructorDeclaratorContext.class,0);
+		}
+		public ConstructorBodyContext constructorBody() {
+			return getRuleContext(ConstructorBodyContext.class,0);
+		}
+		public List<ConstructorModifierContext> constructorModifier() {
+			return getRuleContexts(ConstructorModifierContext.class);
+		}
+		public ConstructorModifierContext constructorModifier(int i) {
+			return getRuleContext(ConstructorModifierContext.class,i);
+		}
+		public Throws_Context throws_() {
+			return getRuleContext(Throws_Context.class,0);
+		}
+		public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_constructorDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterConstructorDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConstructorDeclaration(this);
+		}
+	}
+
+	public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException {
+		ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 156, RULE_constructorDeclaration);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(837);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC))) != 0) || _la==AT) {
+				{
+				{
+				setState(834);
+				constructorModifier();
+				}
+				}
+				setState(839);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(840);
+			constructorDeclarator();
+			setState(842);
+			_la = _input.LA(1);
+			if (_la==THROWS) {
+				{
+				setState(841);
+				throws_();
+				}
+			}
+
+			setState(844);
+			constructorBody();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ConstructorModifierContext extends ParserRuleContext {
+		public AnnotationContext annotation() {
+			return getRuleContext(AnnotationContext.class,0);
+		}
+		public ConstructorModifierContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_constructorModifier; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterConstructorModifier(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConstructorModifier(this);
+		}
+	}
+
+	public final ConstructorModifierContext constructorModifier() throws RecognitionException {
+		ConstructorModifierContext _localctx = new ConstructorModifierContext(_ctx, getState());
+		enterRule(_localctx, 158, RULE_constructorModifier);
+		try {
+			setState(850);
+			switch (_input.LA(1)) {
+			case AT:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(846);
+				annotation();
+				}
+				break;
+			case PUBLIC:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(847);
+				match(PUBLIC);
+				}
+				break;
+			case PROTECTED:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(848);
+				match(PROTECTED);
+				}
+				break;
+			case PRIVATE:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(849);
+				match(PRIVATE);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ConstructorDeclaratorContext extends ParserRuleContext {
+		public SimpleTypeNameContext simpleTypeName() {
+			return getRuleContext(SimpleTypeNameContext.class,0);
+		}
+		public TypeParametersContext typeParameters() {
+			return getRuleContext(TypeParametersContext.class,0);
+		}
+		public FormalParameterListContext formalParameterList() {
+			return getRuleContext(FormalParameterListContext.class,0);
+		}
+		public ConstructorDeclaratorContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_constructorDeclarator; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterConstructorDeclarator(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConstructorDeclarator(this);
+		}
+	}
+
+	public final ConstructorDeclaratorContext constructorDeclarator() throws RecognitionException {
+		ConstructorDeclaratorContext _localctx = new ConstructorDeclaratorContext(_ctx, getState());
+		enterRule(_localctx, 160, RULE_constructorDeclarator);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(853);
+			_la = _input.LA(1);
+			if (_la==LT) {
+				{
+				setState(852);
+				typeParameters();
+				}
+			}
+
+			setState(855);
+			simpleTypeName();
+			setState(856);
+			match(LPAREN);
+			setState(858);
+			_la = _input.LA(1);
+			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==Identifier || _la==AT) {
+				{
+				setState(857);
+				formalParameterList();
+				}
+			}
+
+			setState(860);
+			match(RPAREN);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class SimpleTypeNameContext extends ParserRuleContext {
+		public SimpleTypeNameContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_simpleTypeName; }
+	 
+		public SimpleTypeNameContext() { }
+		public void copyFrom(SimpleTypeNameContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class ConstructorNameContext extends SimpleTypeNameContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public ConstructorNameContext(SimpleTypeNameContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterConstructorName(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConstructorName(this);
+		}
+	}
+
+	public final SimpleTypeNameContext simpleTypeName() throws RecognitionException {
+		SimpleTypeNameContext _localctx = new SimpleTypeNameContext(_ctx, getState());
+		enterRule(_localctx, 162, RULE_simpleTypeName);
+		try {
+			_localctx = new ConstructorNameContext(_localctx);
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(862);
+			match(Identifier);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ConstructorBodyContext extends ParserRuleContext {
+		public ExplicitConstructorInvocationContext explicitConstructorInvocation() {
+			return getRuleContext(ExplicitConstructorInvocationContext.class,0);
+		}
+		public BlockStatementsContext blockStatements() {
+			return getRuleContext(BlockStatementsContext.class,0);
+		}
+		public ConstructorBodyContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_constructorBody; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterConstructorBody(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConstructorBody(this);
+		}
+	}
+
+	public final ConstructorBodyContext constructorBody() throws RecognitionException {
+		ConstructorBodyContext _localctx = new ConstructorBodyContext(_ctx, getState());
+		enterRule(_localctx, 164, RULE_constructorBody);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(864);
+			match(LBRACE);
+			setState(866);
+			switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
+			case 1:
+				{
+				setState(865);
+				explicitConstructorInvocation();
+				}
+				break;
+			}
+			setState(869);
+			switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
+			case 1:
+				{
+				setState(868);
+				blockStatements();
+				}
+				break;
+			}
+			setState(871);
+			match(RBRACE);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ExplicitConstructorInvocationContext extends ParserRuleContext {
+		public TypeArgumentsContext typeArguments() {
+			return getRuleContext(TypeArgumentsContext.class,0);
+		}
+		public ArgumentListContext argumentList() {
+			return getRuleContext(ArgumentListContext.class,0);
+		}
+		public ExpressionNameContext expressionName() {
+			return getRuleContext(ExpressionNameContext.class,0);
+		}
+		public PrimaryContext primary() {
+			return getRuleContext(PrimaryContext.class,0);
+		}
+		public ExplicitConstructorInvocationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_explicitConstructorInvocation; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterExplicitConstructorInvocation(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitExplicitConstructorInvocation(this);
+		}
+	}
+
+	public final ExplicitConstructorInvocationContext explicitConstructorInvocation() throws RecognitionException {
+		ExplicitConstructorInvocationContext _localctx = new ExplicitConstructorInvocationContext(_ctx, getState());
+		enterRule(_localctx, 166, RULE_explicitConstructorInvocation);
+		int _la;
+		try {
+			setState(919);
+			switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(874);
+				_la = _input.LA(1);
+				if (_la==LT) {
+					{
+					setState(873);
+					typeArguments();
+					}
+				}
+
+				setState(876);
+				match(THIS);
+				setState(877);
+				match(LPAREN);
+				setState(879);
+				switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
+				case 1:
+					{
+					setState(878);
+					argumentList();
+					}
+					break;
+				}
+				setState(881);
+				match(RPAREN);
+				setState(882);
+				match(SEMI);
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(884);
+				_la = _input.LA(1);
+				if (_la==LT) {
+					{
+					setState(883);
+					typeArguments();
+					}
+				}
+
+				setState(886);
+				match(SUPER);
+				setState(887);
+				match(LPAREN);
+				setState(889);
+				switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) {
+				case 1:
+					{
+					setState(888);
+					argumentList();
+					}
+					break;
+				}
+				setState(891);
+				match(RPAREN);
+				setState(892);
+				match(SEMI);
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(893);
+				expressionName();
+				setState(894);
+				match(DOT);
+				setState(896);
+				_la = _input.LA(1);
+				if (_la==LT) {
+					{
+					setState(895);
+					typeArguments();
+					}
+				}
+
+				setState(898);
+				match(SUPER);
+				setState(899);
+				match(LPAREN);
+				setState(901);
+				switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) {
+				case 1:
+					{
+					setState(900);
+					argumentList();
+					}
+					break;
+				}
+				setState(903);
+				match(RPAREN);
+				setState(904);
+				match(SEMI);
+				}
+				break;
+			case 4:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(906);
+				primary();
+				setState(907);
+				match(DOT);
+				setState(909);
+				_la = _input.LA(1);
+				if (_la==LT) {
+					{
+					setState(908);
+					typeArguments();
+					}
+				}
+
+				setState(911);
+				match(SUPER);
+				setState(912);
+				match(LPAREN);
+				setState(914);
+				switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
+				case 1:
+					{
+					setState(913);
+					argumentList();
+					}
+					break;
+				}
+				setState(916);
+				match(RPAREN);
+				setState(917);
+				match(SEMI);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class EnumDeclarationContext extends ParserRuleContext {
+		public EnumDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_enumDeclaration; }
+	 
+		public EnumDeclarationContext() { }
+		public void copyFrom(EnumDeclarationContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class EnumNameContext extends EnumDeclarationContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public EnumBodyContext enumBody() {
+			return getRuleContext(EnumBodyContext.class,0);
+		}
+		public List<ClassModifierContext> classModifier() {
+			return getRuleContexts(ClassModifierContext.class);
+		}
+		public ClassModifierContext classModifier(int i) {
+			return getRuleContext(ClassModifierContext.class,i);
+		}
+		public SuperinterfacesContext superinterfaces() {
+			return getRuleContext(SuperinterfacesContext.class,0);
+		}
+		public EnumNameContext(EnumDeclarationContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterEnumName(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitEnumName(this);
+		}
+	}
+
+	public final EnumDeclarationContext enumDeclaration() throws RecognitionException {
+		EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 168, RULE_enumDeclaration);
+		int _la;
+		try {
+			_localctx = new EnumNameContext(_localctx);
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(924);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
+				{
+				{
+				setState(921);
+				classModifier();
+				}
+				}
+				setState(926);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(927);
+			match(ENUM);
+			setState(928);
+			match(Identifier);
+			setState(930);
+			_la = _input.LA(1);
+			if (_la==IMPLEMENTS) {
+				{
+				setState(929);
+				superinterfaces();
+				}
+			}
+
+			setState(932);
+			enumBody();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class EnumBodyContext extends ParserRuleContext {
+		public EnumConstantListContext enumConstantList() {
+			return getRuleContext(EnumConstantListContext.class,0);
+		}
+		public EnumBodyDeclarationsContext enumBodyDeclarations() {
+			return getRuleContext(EnumBodyDeclarationsContext.class,0);
+		}
+		public EnumBodyContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_enumBody; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterEnumBody(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitEnumBody(this);
+		}
+	}
+
+	public final EnumBodyContext enumBody() throws RecognitionException {
+		EnumBodyContext _localctx = new EnumBodyContext(_ctx, getState());
+		enterRule(_localctx, 170, RULE_enumBody);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(934);
+			match(LBRACE);
+			setState(936);
+			_la = _input.LA(1);
+			if (_la==Identifier || _la==AT) {
+				{
+				setState(935);
+				enumConstantList();
+				}
+			}
+
+			setState(939);
+			_la = _input.LA(1);
+			if (_la==COMMA) {
+				{
+				setState(938);
+				match(COMMA);
+				}
+			}
+
+			setState(942);
+			_la = _input.LA(1);
+			if (_la==SEMI) {
+				{
+				setState(941);
+				enumBodyDeclarations();
+				}
+			}
+
+			setState(944);
+			match(RBRACE);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class EnumConstantListContext extends ParserRuleContext {
+		public List<EnumConstantContext> enumConstant() {
+			return getRuleContexts(EnumConstantContext.class);
+		}
+		public EnumConstantContext enumConstant(int i) {
+			return getRuleContext(EnumConstantContext.class,i);
+		}
+		public EnumConstantListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_enumConstantList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterEnumConstantList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitEnumConstantList(this);
+		}
+	}
+
+	public final EnumConstantListContext enumConstantList() throws RecognitionException {
+		EnumConstantListContext _localctx = new EnumConstantListContext(_ctx, getState());
+		enterRule(_localctx, 172, RULE_enumConstantList);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(946);
+			enumConstant();
+			setState(951);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,110,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(947);
+					match(COMMA);
+					setState(948);
+					enumConstant();
+					}
+					} 
+				}
+				setState(953);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,110,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class EnumConstantContext extends ParserRuleContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public List<EnumConstantModifierContext> enumConstantModifier() {
+			return getRuleContexts(EnumConstantModifierContext.class);
+		}
+		public EnumConstantModifierContext enumConstantModifier(int i) {
+			return getRuleContext(EnumConstantModifierContext.class,i);
+		}
+		public ClassBodyContext classBody() {
+			return getRuleContext(ClassBodyContext.class,0);
+		}
+		public ArgumentListContext argumentList() {
+			return getRuleContext(ArgumentListContext.class,0);
+		}
+		public EnumConstantContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_enumConstant; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterEnumConstant(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitEnumConstant(this);
+		}
+	}
+
+	public final EnumConstantContext enumConstant() throws RecognitionException {
+		EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState());
+		enterRule(_localctx, 174, RULE_enumConstant);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(957);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==AT) {
+				{
+				{
+				setState(954);
+				enumConstantModifier();
+				}
+				}
+				setState(959);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(960);
+			match(Identifier);
+			setState(966);
+			_la = _input.LA(1);
+			if (_la==LPAREN) {
+				{
+				setState(961);
+				match(LPAREN);
+				setState(963);
+				switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) {
+				case 1:
+					{
+					setState(962);
+					argumentList();
+					}
+					break;
+				}
+				setState(965);
+				match(RPAREN);
+				}
+			}
+
+			setState(969);
+			_la = _input.LA(1);
+			if (_la==LBRACE) {
+				{
+				setState(968);
+				classBody();
+				}
+			}
+
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class EnumConstantModifierContext extends ParserRuleContext {
+		public AnnotationContext annotation() {
+			return getRuleContext(AnnotationContext.class,0);
+		}
+		public EnumConstantModifierContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_enumConstantModifier; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterEnumConstantModifier(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitEnumConstantModifier(this);
+		}
+	}
+
+	public final EnumConstantModifierContext enumConstantModifier() throws RecognitionException {
+		EnumConstantModifierContext _localctx = new EnumConstantModifierContext(_ctx, getState());
+		enterRule(_localctx, 176, RULE_enumConstantModifier);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(971);
+			annotation();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class EnumBodyDeclarationsContext extends ParserRuleContext {
+		public List<ClassBodyDeclarationContext> classBodyDeclaration() {
+			return getRuleContexts(ClassBodyDeclarationContext.class);
+		}
+		public ClassBodyDeclarationContext classBodyDeclaration(int i) {
+			return getRuleContext(ClassBodyDeclarationContext.class,i);
+		}
+		public EnumBodyDeclarationsContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_enumBodyDeclarations; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterEnumBodyDeclarations(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitEnumBodyDeclarations(this);
+		}
+	}
+
+	public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException {
+		EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState());
+		enterRule(_localctx, 178, RULE_enumBodyDeclarations);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(973);
+			match(SEMI);
+			setState(977);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,115,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(974);
+					classBodyDeclaration();
+					}
+					} 
+				}
+				setState(979);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,115,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ArgumentListContext extends ParserRuleContext {
+		public List<ExpressionContext> expression() {
+			return getRuleContexts(ExpressionContext.class);
+		}
+		public ExpressionContext expression(int i) {
+			return getRuleContext(ExpressionContext.class,i);
+		}
+		public ArgumentListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_argumentList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterArgumentList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitArgumentList(this);
+		}
+	}
+
+	public final ArgumentListContext argumentList() throws RecognitionException {
+		ArgumentListContext _localctx = new ArgumentListContext(_ctx, getState());
+		enterRule(_localctx, 180, RULE_argumentList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(980);
+			expression();
+			setState(985);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==COMMA) {
+				{
+				{
+				setState(981);
+				match(COMMA);
+				setState(982);
+				expression();
+				}
+				}
+				setState(987);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ExpressionContext extends ParserRuleContext {
+		public ExpressionContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_expression; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitExpression(this);
+		}
+	}
+
+	public final ExpressionContext expression() throws RecognitionException {
+		ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
+		enterRule(_localctx, 182, RULE_expression);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(989); 
+			_errHandler.sync(this);
+			_alt = 1+1;
+			do {
+				switch (_alt) {
+				case 1+1:
+					{
+					{
+					setState(988);
+					matchWildcard();
+					}
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				setState(991); 
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,117,_ctx);
+			} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ConditionalExpressionContext extends ParserRuleContext {
+		public ConditionalExpressionContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_conditionalExpression; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterConditionalExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConditionalExpression(this);
+		}
+	}
+
+	public final ConditionalExpressionContext conditionalExpression() throws RecognitionException {
+		ConditionalExpressionContext _localctx = new ConditionalExpressionContext(_ctx, getState());
+		enterRule(_localctx, 184, RULE_conditionalExpression);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(994); 
+			_errHandler.sync(this);
+			_alt = 1+1;
+			do {
+				switch (_alt) {
+				case 1+1:
+					{
+					{
+					setState(993);
+					matchWildcard();
+					}
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				setState(996); 
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,118,_ctx);
+			} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class PrimaryContext extends ParserRuleContext {
+		public PrimaryContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_primary; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterPrimary(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitPrimary(this);
+		}
+	}
+
+	public final PrimaryContext primary() throws RecognitionException {
+		PrimaryContext _localctx = new PrimaryContext(_ctx, getState());
+		enterRule(_localctx, 186, RULE_primary);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(999); 
+			_errHandler.sync(this);
+			_alt = 1+1;
+			do {
+				switch (_alt) {
+				case 1+1:
+					{
+					{
+					setState(998);
+					matchWildcard();
+					}
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				setState(1001); 
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,119,_ctx);
+			} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InterfaceDeclarationContext extends ParserRuleContext {
+		public NormalInterfaceDeclarationContext normalInterfaceDeclaration() {
+			return getRuleContext(NormalInterfaceDeclarationContext.class,0);
+		}
+		public AnnotationTypeDeclarationContext annotationTypeDeclaration() {
+			return getRuleContext(AnnotationTypeDeclarationContext.class,0);
+		}
+		public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_interfaceDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterInterfaceDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceDeclaration(this);
+		}
+	}
+
+	public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException {
+		InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 188, RULE_interfaceDeclaration);
+		try {
+			setState(1005);
+			switch ( getInterpreter().adaptivePredict(_input,120,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1003);
+				normalInterfaceDeclaration();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1004);
+				annotationTypeDeclaration();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class NormalInterfaceDeclarationContext extends ParserRuleContext {
+		public NormalInterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_normalInterfaceDeclaration; }
+	 
+		public NormalInterfaceDeclarationContext() { }
+		public void copyFrom(NormalInterfaceDeclarationContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class IfaceNameContext extends NormalInterfaceDeclarationContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public InterfaceBodyContext interfaceBody() {
+			return getRuleContext(InterfaceBodyContext.class,0);
+		}
+		public List<InterfaceModifierContext> interfaceModifier() {
+			return getRuleContexts(InterfaceModifierContext.class);
+		}
+		public InterfaceModifierContext interfaceModifier(int i) {
+			return getRuleContext(InterfaceModifierContext.class,i);
+		}
+		public TypeParametersContext typeParameters() {
+			return getRuleContext(TypeParametersContext.class,0);
+		}
+		public ExtendsInterfacesContext extendsInterfaces() {
+			return getRuleContext(ExtendsInterfacesContext.class,0);
+		}
+		public IfaceNameContext(NormalInterfaceDeclarationContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterIfaceName(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitIfaceName(this);
+		}
+	}
+
+	public final NormalInterfaceDeclarationContext normalInterfaceDeclaration() throws RecognitionException {
+		NormalInterfaceDeclarationContext _localctx = new NormalInterfaceDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 190, RULE_normalInterfaceDeclaration);
+		int _la;
+		try {
+			_localctx = new IfaceNameContext(_localctx);
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1010);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
+				{
+				{
+				setState(1007);
+				interfaceModifier();
+				}
+				}
+				setState(1012);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(1013);
+			match(INTERFACE);
+			setState(1014);
+			match(Identifier);
+			setState(1016);
+			_la = _input.LA(1);
+			if (_la==LT) {
+				{
+				setState(1015);
+				typeParameters();
+				}
+			}
+
+			setState(1019);
+			_la = _input.LA(1);
+			if (_la==EXTENDS) {
+				{
+				setState(1018);
+				extendsInterfaces();
+				}
+			}
+
+			setState(1021);
+			interfaceBody();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InterfaceModifierContext extends ParserRuleContext {
+		public AnnotationContext annotation() {
+			return getRuleContext(AnnotationContext.class,0);
+		}
+		public InterfaceModifierContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_interfaceModifier; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterInterfaceModifier(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceModifier(this);
+		}
+	}
+
+	public final InterfaceModifierContext interfaceModifier() throws RecognitionException {
+		InterfaceModifierContext _localctx = new InterfaceModifierContext(_ctx, getState());
+		enterRule(_localctx, 192, RULE_interfaceModifier);
+		try {
+			setState(1030);
+			switch (_input.LA(1)) {
+			case AT:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1023);
+				annotation();
+				}
+				break;
+			case PUBLIC:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1024);
+				match(PUBLIC);
+				}
+				break;
+			case PROTECTED:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(1025);
+				match(PROTECTED);
+				}
+				break;
+			case PRIVATE:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(1026);
+				match(PRIVATE);
+				}
+				break;
+			case ABSTRACT:
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(1027);
+				match(ABSTRACT);
+				}
+				break;
+			case STATIC:
+				enterOuterAlt(_localctx, 6);
+				{
+				setState(1028);
+				match(STATIC);
+				}
+				break;
+			case STRICTFP:
+				enterOuterAlt(_localctx, 7);
+				{
+				setState(1029);
+				match(STRICTFP);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ExtendsInterfacesContext extends ParserRuleContext {
+		public InterfaceTypeListContext interfaceTypeList() {
+			return getRuleContext(InterfaceTypeListContext.class,0);
+		}
+		public ExtendsInterfacesContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_extendsInterfaces; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterExtendsInterfaces(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitExtendsInterfaces(this);
+		}
+	}
+
+	public final ExtendsInterfacesContext extendsInterfaces() throws RecognitionException {
+		ExtendsInterfacesContext _localctx = new ExtendsInterfacesContext(_ctx, getState());
+		enterRule(_localctx, 194, RULE_extendsInterfaces);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1032);
+			match(EXTENDS);
+			setState(1033);
+			interfaceTypeList();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InterfaceBodyContext extends ParserRuleContext {
+		public List<InterfaceMemberDeclarationContext> interfaceMemberDeclaration() {
+			return getRuleContexts(InterfaceMemberDeclarationContext.class);
+		}
+		public InterfaceMemberDeclarationContext interfaceMemberDeclaration(int i) {
+			return getRuleContext(InterfaceMemberDeclarationContext.class,i);
+		}
+		public InterfaceBodyContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_interfaceBody; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterInterfaceBody(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceBody(this);
+		}
+	}
+
+	public final InterfaceBodyContext interfaceBody() throws RecognitionException {
+		InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState());
+		enterRule(_localctx, 196, RULE_interfaceBody);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1035);
+			match(LBRACE);
+			setState(1039);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DEFAULT) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << VOID) | (1L << SEMI))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - 68)) | (1L << (Identifier - 68)) | (1L << (AT - 68)))) != 0)) {
+				{
+				{
+				setState(1036);
+				interfaceMemberDeclaration();
+				}
+				}
+				setState(1041);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(1042);
+			match(RBRACE);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InterfaceMemberDeclarationContext extends ParserRuleContext {
+		public ConstantDeclarationContext constantDeclaration() {
+			return getRuleContext(ConstantDeclarationContext.class,0);
+		}
+		public InterfaceMethodDeclarationContext interfaceMethodDeclaration() {
+			return getRuleContext(InterfaceMethodDeclarationContext.class,0);
+		}
+		public ClassDeclarationContext classDeclaration() {
+			return getRuleContext(ClassDeclarationContext.class,0);
+		}
+		public InterfaceDeclarationContext interfaceDeclaration() {
+			return getRuleContext(InterfaceDeclarationContext.class,0);
+		}
+		public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_interfaceMemberDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterInterfaceMemberDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceMemberDeclaration(this);
+		}
+	}
+
+	public final InterfaceMemberDeclarationContext interfaceMemberDeclaration() throws RecognitionException {
+		InterfaceMemberDeclarationContext _localctx = new InterfaceMemberDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 198, RULE_interfaceMemberDeclaration);
+		try {
+			setState(1049);
+			switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1044);
+				constantDeclaration();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1045);
+				interfaceMethodDeclaration();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(1046);
+				classDeclaration();
+				}
+				break;
+			case 4:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(1047);
+				interfaceDeclaration();
+				}
+				break;
+			case 5:
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(1048);
+				match(SEMI);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ConstantDeclarationContext extends ParserRuleContext {
+		public UnannTypeContext unannType() {
+			return getRuleContext(UnannTypeContext.class,0);
+		}
+		public List<ConstantModifierContext> constantModifier() {
+			return getRuleContexts(ConstantModifierContext.class);
+		}
+		public ConstantModifierContext constantModifier(int i) {
+			return getRuleContext(ConstantModifierContext.class,i);
+		}
+		public ConstantDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_constantDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterConstantDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConstantDeclaration(this);
+		}
+	}
+
+	public final ConstantDeclarationContext constantDeclaration() throws RecognitionException {
+		ConstantDeclarationContext _localctx = new ConstantDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 200, RULE_constantDeclaration);
+		int _la;
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1054);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FINAL) | (1L << PUBLIC) | (1L << STATIC))) != 0) || _la==AT) {
+				{
+				{
+				setState(1051);
+				constantModifier();
+				}
+				}
+				setState(1056);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(1057);
+			unannType();
+			setState(1059); 
+			_errHandler.sync(this);
+			_alt = 1+1;
+			do {
+				switch (_alt) {
+				case 1+1:
+					{
+					{
+					setState(1058);
+					matchWildcard();
+					}
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				setState(1061); 
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,128,_ctx);
+			} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+			setState(1063);
+			match(SEMI);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ConstantModifierContext extends ParserRuleContext {
+		public AnnotationContext annotation() {
+			return getRuleContext(AnnotationContext.class,0);
+		}
+		public ConstantModifierContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_constantModifier; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterConstantModifier(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConstantModifier(this);
+		}
+	}
+
+	public final ConstantModifierContext constantModifier() throws RecognitionException {
+		ConstantModifierContext _localctx = new ConstantModifierContext(_ctx, getState());
+		enterRule(_localctx, 202, RULE_constantModifier);
+		try {
+			setState(1069);
+			switch (_input.LA(1)) {
+			case AT:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1065);
+				annotation();
+				}
+				break;
+			case PUBLIC:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1066);
+				match(PUBLIC);
+				}
+				break;
+			case STATIC:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(1067);
+				match(STATIC);
+				}
+				break;
+			case FINAL:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(1068);
+				match(FINAL);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InterfaceMethodDeclarationContext extends ParserRuleContext {
+		public MethodHeaderContext methodHeader() {
+			return getRuleContext(MethodHeaderContext.class,0);
+		}
+		public MethodBodyContext methodBody() {
+			return getRuleContext(MethodBodyContext.class,0);
+		}
+		public List<InterfaceMethodModifierContext> interfaceMethodModifier() {
+			return getRuleContexts(InterfaceMethodModifierContext.class);
+		}
+		public InterfaceMethodModifierContext interfaceMethodModifier(int i) {
+			return getRuleContext(InterfaceMethodModifierContext.class,i);
+		}
+		public InterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_interfaceMethodDeclaration; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterInterfaceMethodDeclaration(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceMethodDeclaration(this);
+		}
+	}
+
+	public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException {
+		InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 204, RULE_interfaceMethodDeclaration);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1074);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << DEFAULT) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
+				{
+				{
+				setState(1071);
+				interfaceMethodModifier();
+				}
+				}
+				setState(1076);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(1077);
+			methodHeader();
+			setState(1078);
+			methodBody();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InterfaceMethodModifierContext extends ParserRuleContext {
+		public AnnotationContext annotation() {
+			return getRuleContext(AnnotationContext.class,0);
+		}
+		public InterfaceMethodModifierContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_interfaceMethodModifier; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterInterfaceMethodModifier(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceMethodModifier(this);
+		}
+	}
+
+	public final InterfaceMethodModifierContext interfaceMethodModifier() throws RecognitionException {
+		InterfaceMethodModifierContext _localctx = new InterfaceMethodModifierContext(_ctx, getState());
+		enterRule(_localctx, 206, RULE_interfaceMethodModifier);
+		try {
+			setState(1086);
+			switch (_input.LA(1)) {
+			case AT:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1080);
+				annotation();
+				}
+				break;
+			case PUBLIC:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1081);
+				match(PUBLIC);
+				}
+				break;
+			case ABSTRACT:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(1082);
+				match(ABSTRACT);
+				}
+				break;
+			case DEFAULT:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(1083);
+				match(DEFAULT);
+				}
+				break;
+			case STATIC:
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(1084);
+				match(STATIC);
+				}
+				break;
+			case STRICTFP:
+				enterOuterAlt(_localctx, 6);
+				{
+				setState(1085);
+				match(STRICTFP);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class AnnotationTypeDeclarationContext extends ParserRuleContext {
+		public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_annotationTypeDeclaration; }
+	 
+		public AnnotationTypeDeclarationContext() { }
+		public void copyFrom(AnnotationTypeDeclarationContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class AnnoNameContext extends AnnotationTypeDeclarationContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public AnnotationTypeBodyContext annotationTypeBody() {
+			return getRuleContext(AnnotationTypeBodyContext.class,0);
+		}
+		public List<InterfaceModifierContext> interfaceModifier() {
+			return getRuleContexts(InterfaceModifierContext.class);
+		}
+		public InterfaceModifierContext interfaceModifier(int i) {
+			return getRuleContext(InterfaceModifierContext.class,i);
+		}
+		public AnnoNameContext(AnnotationTypeDeclarationContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterAnnoName(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitAnnoName(this);
+		}
+	}
+
+	public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException {
+		AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(_ctx, getState());
+		enterRule(_localctx, 208, RULE_annotationTypeDeclaration);
+		try {
+			int _alt;
+			_localctx = new AnnoNameContext(_localctx);
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1091);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,132,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(1088);
+					interfaceModifier();
+					}
+					} 
+				}
+				setState(1093);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,132,_ctx);
+			}
+			setState(1094);
+			match(AT);
+			setState(1095);
+			match(INTERFACE);
+			setState(1096);
+			match(Identifier);
+			setState(1097);
+			annotationTypeBody();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class AnnotationTypeBodyContext extends ParserRuleContext {
+		public AnnotationTypeBodyContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_annotationTypeBody; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterAnnotationTypeBody(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitAnnotationTypeBody(this);
+		}
+	}
+
+	public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionException {
+		AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(_ctx, getState());
+		enterRule(_localctx, 210, RULE_annotationTypeBody);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1099);
+			match(LBRACE);
+			setState(1101); 
+			_errHandler.sync(this);
+			_alt = 1+1;
+			do {
+				switch (_alt) {
+				case 1+1:
+					{
+					{
+					setState(1100);
+					matchWildcard();
+					}
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				setState(1103); 
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,133,_ctx);
+			} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+			setState(1105);
+			match(RBRACE);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class AnnotationContext extends ParserRuleContext {
+		public NormalAnnotationContext normalAnnotation() {
+			return getRuleContext(NormalAnnotationContext.class,0);
+		}
+		public MarkerAnnotationContext markerAnnotation() {
+			return getRuleContext(MarkerAnnotationContext.class,0);
+		}
+		public SingleElementAnnotationContext singleElementAnnotation() {
+			return getRuleContext(SingleElementAnnotationContext.class,0);
+		}
+		public AnnotationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_annotation; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterAnnotation(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitAnnotation(this);
+		}
+	}
+
+	public final AnnotationContext annotation() throws RecognitionException {
+		AnnotationContext _localctx = new AnnotationContext(_ctx, getState());
+		enterRule(_localctx, 212, RULE_annotation);
+		try {
+			setState(1110);
+			switch ( getInterpreter().adaptivePredict(_input,134,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1107);
+				normalAnnotation();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1108);
+				markerAnnotation();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(1109);
+				singleElementAnnotation();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class NormalAnnotationContext extends ParserRuleContext {
+		public TypeNameContext typeName() {
+			return getRuleContext(TypeNameContext.class,0);
+		}
+		public ElementValuePairListContext elementValuePairList() {
+			return getRuleContext(ElementValuePairListContext.class,0);
+		}
+		public NormalAnnotationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_normalAnnotation; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterNormalAnnotation(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitNormalAnnotation(this);
+		}
+	}
+
+	public final NormalAnnotationContext normalAnnotation() throws RecognitionException {
+		NormalAnnotationContext _localctx = new NormalAnnotationContext(_ctx, getState());
+		enterRule(_localctx, 214, RULE_normalAnnotation);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1112);
+			match(AT);
+			setState(1113);
+			typeName();
+			setState(1114);
+			match(LPAREN);
+			setState(1116);
+			_la = _input.LA(1);
+			if (_la==Identifier) {
+				{
+				setState(1115);
+				elementValuePairList();
+				}
+			}
+
+			setState(1118);
+			match(RPAREN);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ElementValuePairListContext extends ParserRuleContext {
+		public List<ElementValuePairContext> elementValuePair() {
+			return getRuleContexts(ElementValuePairContext.class);
+		}
+		public ElementValuePairContext elementValuePair(int i) {
+			return getRuleContext(ElementValuePairContext.class,i);
+		}
+		public ElementValuePairListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_elementValuePairList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterElementValuePairList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitElementValuePairList(this);
+		}
+	}
+
+	public final ElementValuePairListContext elementValuePairList() throws RecognitionException {
+		ElementValuePairListContext _localctx = new ElementValuePairListContext(_ctx, getState());
+		enterRule(_localctx, 216, RULE_elementValuePairList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1120);
+			elementValuePair();
+			setState(1125);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==COMMA) {
+				{
+				{
+				setState(1121);
+				match(COMMA);
+				setState(1122);
+				elementValuePair();
+				}
+				}
+				setState(1127);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ElementValuePairContext extends ParserRuleContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
+		public ElementValueContext elementValue() {
+			return getRuleContext(ElementValueContext.class,0);
+		}
+		public ElementValuePairContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_elementValuePair; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterElementValuePair(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitElementValuePair(this);
+		}
+	}
+
+	public final ElementValuePairContext elementValuePair() throws RecognitionException {
+		ElementValuePairContext _localctx = new ElementValuePairContext(_ctx, getState());
+		enterRule(_localctx, 218, RULE_elementValuePair);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1128);
+			match(Identifier);
+			setState(1129);
+			match(ASSIGN);
+			setState(1130);
+			elementValue();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ElementValueContext extends ParserRuleContext {
+		public ConditionalExpressionContext conditionalExpression() {
+			return getRuleContext(ConditionalExpressionContext.class,0);
+		}
+		public ElementValueArrayInitializerContext elementValueArrayInitializer() {
+			return getRuleContext(ElementValueArrayInitializerContext.class,0);
+		}
+		public AnnotationContext annotation() {
+			return getRuleContext(AnnotationContext.class,0);
+		}
+		public ElementValueContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_elementValue; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterElementValue(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitElementValue(this);
+		}
+	}
+
+	public final ElementValueContext elementValue() throws RecognitionException {
+		ElementValueContext _localctx = new ElementValueContext(_ctx, getState());
+		enterRule(_localctx, 220, RULE_elementValue);
+		try {
+			setState(1135);
+			switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(1132);
+				conditionalExpression();
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(1133);
+				elementValueArrayInitializer();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(1134);
+				annotation();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ElementValueArrayInitializerContext extends ParserRuleContext {
+		public ElementValueListContext elementValueList() {
+			return getRuleContext(ElementValueListContext.class,0);
+		}
+		public ElementValueArrayInitializerContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_elementValueArrayInitializer; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterElementValueArrayInitializer(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitElementValueArrayInitializer(this);
+		}
+	}
+
+	public final ElementValueArrayInitializerContext elementValueArrayInitializer() throws RecognitionException {
+		ElementValueArrayInitializerContext _localctx = new ElementValueArrayInitializerContext(_ctx, getState());
+		enterRule(_localctx, 222, RULE_elementValueArrayInitializer);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1137);
+			match(LBRACE);
+			setState(1139);
+			switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) {
+			case 1:
+				{
+				setState(1138);
+				elementValueList();
+				}
+				break;
+			}
+			setState(1142);
+			_la = _input.LA(1);
+			if (_la==COMMA) {
+				{
+				setState(1141);
+				match(COMMA);
+				}
+			}
+
+			setState(1144);
+			match(RBRACE);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ElementValueListContext extends ParserRuleContext {
+		public List<ElementValueContext> elementValue() {
+			return getRuleContexts(ElementValueContext.class);
+		}
+		public ElementValueContext elementValue(int i) {
+			return getRuleContext(ElementValueContext.class,i);
+		}
+		public ElementValueListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_elementValueList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterElementValueList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitElementValueList(this);
+		}
+	}
+
+	public final ElementValueListContext elementValueList() throws RecognitionException {
+		ElementValueListContext _localctx = new ElementValueListContext(_ctx, getState());
+		enterRule(_localctx, 224, RULE_elementValueList);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1146);
+			elementValue();
+			setState(1151);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,140,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(1147);
+					match(COMMA);
+					setState(1148);
+					elementValue();
+					}
+					} 
+				}
+				setState(1153);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,140,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class MarkerAnnotationContext extends ParserRuleContext {
+		public TypeNameContext typeName() {
+			return getRuleContext(TypeNameContext.class,0);
+		}
+		public MarkerAnnotationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_markerAnnotation; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterMarkerAnnotation(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitMarkerAnnotation(this);
+		}
+	}
+
+	public final MarkerAnnotationContext markerAnnotation() throws RecognitionException {
+		MarkerAnnotationContext _localctx = new MarkerAnnotationContext(_ctx, getState());
+		enterRule(_localctx, 226, RULE_markerAnnotation);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1154);
+			match(AT);
+			setState(1155);
+			typeName();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class SingleElementAnnotationContext extends ParserRuleContext {
+		public TypeNameContext typeName() {
+			return getRuleContext(TypeNameContext.class,0);
+		}
+		public ElementValueContext elementValue() {
+			return getRuleContext(ElementValueContext.class,0);
+		}
+		public SingleElementAnnotationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_singleElementAnnotation; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterSingleElementAnnotation(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitSingleElementAnnotation(this);
+		}
+	}
+
+	public final SingleElementAnnotationContext singleElementAnnotation() throws RecognitionException {
+		SingleElementAnnotationContext _localctx = new SingleElementAnnotationContext(_ctx, getState());
+		enterRule(_localctx, 228, RULE_singleElementAnnotation);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1157);
+			match(AT);
+			setState(1158);
+			typeName();
+			setState(1159);
+			match(LPAREN);
+			setState(1160);
+			elementValue();
+			setState(1161);
+			match(RPAREN);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ArrayInitializerContext extends ParserRuleContext {
+		public VariableInitializerListContext variableInitializerList() {
+			return getRuleContext(VariableInitializerListContext.class,0);
+		}
+		public ArrayInitializerContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_arrayInitializer; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterArrayInitializer(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitArrayInitializer(this);
+		}
+	}
+
+	public final ArrayInitializerContext arrayInitializer() throws RecognitionException {
+		ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState());
+		enterRule(_localctx, 230, RULE_arrayInitializer);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1163);
+			match(LBRACE);
+			setState(1165);
+			switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) {
+			case 1:
+				{
+				setState(1164);
+				variableInitializerList();
+				}
+				break;
+			}
+			setState(1168);
+			_la = _input.LA(1);
+			if (_la==COMMA) {
+				{
+				setState(1167);
+				match(COMMA);
+				}
+			}
+
+			setState(1170);
+			match(RBRACE);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class VariableInitializerListContext extends ParserRuleContext {
+		public List<VariableInitializerContext> variableInitializer() {
+			return getRuleContexts(VariableInitializerContext.class);
+		}
+		public VariableInitializerContext variableInitializer(int i) {
+			return getRuleContext(VariableInitializerContext.class,i);
+		}
+		public VariableInitializerListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_variableInitializerList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterVariableInitializerList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitVariableInitializerList(this);
+		}
+	}
+
+	public final VariableInitializerListContext variableInitializerList() throws RecognitionException {
+		VariableInitializerListContext _localctx = new VariableInitializerListContext(_ctx, getState());
+		enterRule(_localctx, 232, RULE_variableInitializerList);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1172);
+			variableInitializer();
+			setState(1177);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,143,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(1173);
+					match(COMMA);
+					setState(1174);
+					variableInitializer();
+					}
+					} 
+				}
+				setState(1179);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,143,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class BlockContext extends ParserRuleContext {
+		public BlockStatementsContext blockStatements() {
+			return getRuleContext(BlockStatementsContext.class,0);
+		}
+		public BlockContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_block; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterBlock(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitBlock(this);
+		}
+	}
+
+	public final BlockContext block() throws RecognitionException {
+		BlockContext _localctx = new BlockContext(_ctx, getState());
+		enterRule(_localctx, 234, RULE_block);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1180);
+			match(LBRACE);
+			setState(1182);
+			switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) {
+			case 1:
+				{
+				setState(1181);
+				blockStatements();
+				}
+				break;
+			}
+			setState(1184);
+			match(RBRACE);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class BlockStatementsContext extends ParserRuleContext {
+		public BlockStatementsContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_blockStatements; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterBlockStatements(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitBlockStatements(this);
+		}
+	}
+
+	public final BlockStatementsContext blockStatements() throws RecognitionException {
+		BlockStatementsContext _localctx = new BlockStatementsContext(_ctx, getState());
+		enterRule(_localctx, 236, RULE_blockStatements);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(1187); 
+			_errHandler.sync(this);
+			_alt = 1+1;
+			do {
+				switch (_alt) {
+				case 1+1:
+					{
+					{
+					setState(1186);
+					matchWildcard();
+					}
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				setState(1189); 
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,145,_ctx);
+			} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
+		switch (ruleIndex) {
+		case 25:
+			return packageOrTypeName_sempred((PackageOrTypeNameContext)_localctx, predIndex);
+		case 27:
+			return ambiguousName_sempred((AmbiguousNameContext)_localctx, predIndex);
+		}
+		return true;
+	}
+	private boolean packageOrTypeName_sempred(PackageOrTypeNameContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 0:
+			return precpred(_ctx, 1);
+		}
+		return true;
+	}
+	private boolean ambiguousName_sempred(AmbiguousNameContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 1:
+			return precpred(_ctx, 1);
+		}
+		return true;
+	}
+
+	public static final String _serializedATN =
+		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3m\u04aa\4\2\t\2\4"+
+		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
+		"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
+		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
+		"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
+		"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
+		",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
+		"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
+		"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
+		"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
+		"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
+		"`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
+		"k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
+		"w\tw\4x\tx\3\2\7\2\u00f2\n\2\f\2\16\2\u00f5\13\2\3\2\3\2\7\2\u00f9\n\2"+
+		"\f\2\16\2\u00fc\13\2\3\2\5\2\u00ff\n\2\3\3\3\3\5\3\u0103\n\3\3\4\3\4\3"+
+		"\5\3\5\3\6\3\6\3\6\5\6\u010c\n\6\3\7\3\7\5\7\u0110\n\7\3\7\3\7\7\7\u0114"+
+		"\n\7\f\7\16\7\u0117\13\7\3\b\7\b\u011a\n\b\f\b\16\b\u011d\13\b\3\b\3\b"+
+		"\5\b\u0121\n\b\3\b\3\b\3\b\7\b\u0126\n\b\f\b\16\b\u0129\13\b\3\b\3\b\5"+
+		"\b\u012d\n\b\5\b\u012f\n\b\3\t\3\t\7\t\u0133\n\t\f\t\16\t\u0136\13\t\3"+
+		"\t\3\t\5\t\u013a\n\t\3\n\7\n\u013d\n\n\f\n\16\n\u0140\13\n\3\n\3\n\5\n"+
+		"\u0144\n\n\3\13\3\13\3\f\3\f\3\r\3\r\3\16\7\16\u014d\n\16\f\16\16\16\u0150"+
+		"\13\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\5\17\u015d"+
+		"\n\17\3\20\7\20\u0160\n\20\f\20\16\20\u0163\13\20\3\20\3\20\3\20\7\20"+
+		"\u0168\n\20\f\20\16\20\u016b\13\20\3\20\3\20\7\20\u016f\n\20\f\20\16\20"+
+		"\u0172\13\20\3\21\7\21\u0175\n\21\f\21\16\21\u0178\13\21\3\21\3\21\5\21"+
+		"\u017c\n\21\3\22\3\22\3\23\3\23\3\23\3\23\3\23\7\23\u0185\n\23\f\23\16"+
+		"\23\u0188\13\23\5\23\u018a\n\23\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\26"+
+		"\3\26\3\26\7\26\u0196\n\26\f\26\16\26\u0199\13\26\3\27\3\27\5\27\u019d"+
+		"\n\27\3\30\7\30\u01a0\n\30\f\30\16\30\u01a3\13\30\3\30\3\30\5\30\u01a7"+
+		"\n\30\3\31\3\31\3\31\3\31\5\31\u01ad\n\31\3\32\3\32\3\32\3\32\3\32\5\32"+
+		"\u01b4\n\32\3\33\3\33\3\33\3\33\3\33\3\33\7\33\u01bc\n\33\f\33\16\33\u01bf"+
+		"\13\33\3\34\3\34\3\34\3\34\3\34\5\34\u01c6\n\34\3\35\3\35\3\35\3\35\3"+
+		"\35\3\35\7\35\u01ce\n\35\f\35\16\35\u01d1\13\35\3\36\5\36\u01d4\n\36\3"+
+		"\36\7\36\u01d7\n\36\f\36\16\36\u01da\13\36\3\36\7\36\u01dd\n\36\f\36\16"+
+		"\36\u01e0\13\36\3\36\3\36\3\37\7\37\u01e5\n\37\f\37\16\37\u01e8\13\37"+
+		"\3\37\3\37\3\37\3\37\7\37\u01ee\n\37\f\37\16\37\u01f1\13\37\3\37\3\37"+
+		"\3 \3 \3!\3!\3!\3!\5!\u01fb\n!\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3#\3#\3$\3"+
+		"$\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3&\3&\3&\5&\u0218\n&\3\'\3\'\5\'"+
+		"\u021c\n\'\3(\7(\u021f\n(\f(\16(\u0222\13(\3(\3(\3(\5(\u0227\n(\3(\5("+
+		"\u022a\n(\3(\5(\u022d\n(\3(\3(\3)\3)\3)\3)\3)\3)\3)\3)\5)\u0239\n)\3*"+
+		"\3*\3*\3*\3+\3+\3+\7+\u0242\n+\f+\16+\u0245\13+\3,\3,\3,\3-\3-\3-\3.\3"+
+		".\3.\7.\u0250\n.\f.\16.\u0253\13.\3/\3/\7/\u0257\n/\f/\16/\u025a\13/\3"+
+		"/\3/\3\60\3\60\3\60\3\60\5\60\u0262\n\60\3\61\3\61\3\61\3\61\3\61\5\61"+
+		"\u0269\n\61\3\62\6\62\u026c\n\62\r\62\16\62\u026d\3\62\3\62\3\63\3\63"+
+		"\5\63\u0274\n\63\3\64\3\64\5\64\u0278\n\64\3\65\3\65\5\65\u027c\n\65\3"+
+		"\66\3\66\5\66\u0280\n\66\3\67\3\67\3\67\5\67\u0285\n\67\38\38\58\u0289"+
+		"\n8\38\38\78\u028d\n8\f8\168\u0290\138\39\39\79\u0294\n9\f9\169\u0297"+
+		"\139\39\39\59\u029b\n9\3:\3:\5:\u029f\n:\3;\3;\3<\3<\3=\3=\3>\3>\3>\3"+
+		">\3>\3>\3>\3>\3>\5>\u02b0\n>\3?\7?\u02b3\n?\f?\16?\u02b6\13?\3?\3?\3?"+
+		"\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\5@\u02c5\n@\3A\3A\3A\5A\u02ca\nA\3A\3A"+
+		"\7A\u02ce\nA\fA\16A\u02d1\13A\3A\3A\3A\5A\u02d6\nA\5A\u02d8\nA\3B\3B\5"+
+		"B\u02dc\nB\3C\3C\3C\5C\u02e1\nC\3C\3C\5C\u02e5\nC\3D\3D\3D\3D\3D\5D\u02ec"+
+		"\nD\3E\3E\3E\7E\u02f1\nE\fE\16E\u02f4\13E\3E\3E\3E\7E\u02f9\nE\fE\16E"+
+		"\u02fc\13E\5E\u02fe\nE\3F\7F\u0301\nF\fF\16F\u0304\13F\3F\3F\3F\3G\3G"+
+		"\5G\u030b\nG\3H\7H\u030e\nH\fH\16H\u0311\13H\3H\3H\7H\u0315\nH\fH\16H"+
+		"\u0318\13H\3H\3H\3H\3H\5H\u031e\nH\3I\7I\u0321\nI\fI\16I\u0324\13I\3I"+
+		"\3I\3I\5I\u0329\nI\3I\3I\3J\3J\3J\3K\3K\3K\7K\u0333\nK\fK\16K\u0336\13"+
+		"K\3L\3L\5L\u033a\nL\3M\3M\5M\u033e\nM\3N\3N\3O\3O\3O\3P\7P\u0346\nP\f"+
+		"P\16P\u0349\13P\3P\3P\5P\u034d\nP\3P\3P\3Q\3Q\3Q\3Q\5Q\u0355\nQ\3R\5R"+
+		"\u0358\nR\3R\3R\3R\5R\u035d\nR\3R\3R\3S\3S\3T\3T\5T\u0365\nT\3T\5T\u0368"+
+		"\nT\3T\3T\3U\5U\u036d\nU\3U\3U\3U\5U\u0372\nU\3U\3U\3U\5U\u0377\nU\3U"+
+		"\3U\3U\5U\u037c\nU\3U\3U\3U\3U\3U\5U\u0383\nU\3U\3U\3U\5U\u0388\nU\3U"+
+		"\3U\3U\3U\3U\3U\5U\u0390\nU\3U\3U\3U\5U\u0395\nU\3U\3U\3U\5U\u039a\nU"+
+		"\3V\7V\u039d\nV\fV\16V\u03a0\13V\3V\3V\3V\5V\u03a5\nV\3V\3V\3W\3W\5W\u03ab"+
+		"\nW\3W\5W\u03ae\nW\3W\5W\u03b1\nW\3W\3W\3X\3X\3X\7X\u03b8\nX\fX\16X\u03bb"+
+		"\13X\3Y\7Y\u03be\nY\fY\16Y\u03c1\13Y\3Y\3Y\3Y\5Y\u03c6\nY\3Y\5Y\u03c9"+
+		"\nY\3Y\5Y\u03cc\nY\3Z\3Z\3[\3[\7[\u03d2\n[\f[\16[\u03d5\13[\3\\\3\\\3"+
+		"\\\7\\\u03da\n\\\f\\\16\\\u03dd\13\\\3]\6]\u03e0\n]\r]\16]\u03e1\3^\6"+
+		"^\u03e5\n^\r^\16^\u03e6\3_\6_\u03ea\n_\r_\16_\u03eb\3`\3`\5`\u03f0\n`"+
+		"\3a\7a\u03f3\na\fa\16a\u03f6\13a\3a\3a\3a\5a\u03fb\na\3a\5a\u03fe\na\3"+
+		"a\3a\3b\3b\3b\3b\3b\3b\3b\5b\u0409\nb\3c\3c\3c\3d\3d\7d\u0410\nd\fd\16"+
+		"d\u0413\13d\3d\3d\3e\3e\3e\3e\3e\5e\u041c\ne\3f\7f\u041f\nf\ff\16f\u0422"+
+		"\13f\3f\3f\6f\u0426\nf\rf\16f\u0427\3f\3f\3g\3g\3g\3g\5g\u0430\ng\3h\7"+
+		"h\u0433\nh\fh\16h\u0436\13h\3h\3h\3h\3i\3i\3i\3i\3i\3i\5i\u0441\ni\3j"+
+		"\7j\u0444\nj\fj\16j\u0447\13j\3j\3j\3j\3j\3j\3k\3k\6k\u0450\nk\rk\16k"+
+		"\u0451\3k\3k\3l\3l\3l\5l\u0459\nl\3m\3m\3m\3m\5m\u045f\nm\3m\3m\3n\3n"+
+		"\3n\7n\u0466\nn\fn\16n\u0469\13n\3o\3o\3o\3o\3p\3p\3p\5p\u0472\np\3q\3"+
+		"q\5q\u0476\nq\3q\5q\u0479\nq\3q\3q\3r\3r\3r\7r\u0480\nr\fr\16r\u0483\13"+
+		"r\3s\3s\3s\3t\3t\3t\3t\3t\3t\3u\3u\5u\u0490\nu\3u\5u\u0493\nu\3u\3u\3"+
+		"v\3v\3v\7v\u049a\nv\fv\16v\u049d\13v\3w\3w\5w\u04a1\nw\3w\3w\3x\6x\u04a6"+
+		"\nx\rx\16x\u04a7\3x\t\u026d\u03e1\u03e6\u03eb\u0427\u0451\u04a7\4\648"+
+		"y\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDF"+
+		"HJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c"+
+		"\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4"+
+		"\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc"+
+		"\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4"+
+		"\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec"+
+		"\u00ee\2\4\7\2\7\7\n\n\35\35\37\37\'\'\4\2\20\20\26\26\u04f2\2\u00fe\3"+
+		"\2\2\2\4\u0102\3\2\2\2\6\u0104\3\2\2\2\b\u0106\3\2\2\2\n\u010b\3\2\2\2"+
+		"\f\u010f\3\2\2\2\16\u012e\3\2\2\2\20\u0130\3\2\2\2\22\u013e\3\2\2\2\24"+
+		"\u0145\3\2\2\2\26\u0147\3\2\2\2\30\u0149\3\2\2\2\32\u014e\3\2\2\2\34\u015c"+
+		"\3\2\2\2\36\u0161\3\2\2\2 \u0176\3\2\2\2\"\u017d\3\2\2\2$\u0189\3\2\2"+
+		"\2&\u018b\3\2\2\2(\u018e\3\2\2\2*\u0192\3\2\2\2,\u019c\3\2\2\2.\u01a1"+
+		"\3\2\2\2\60\u01ac\3\2\2\2\62\u01b3\3\2\2\2\64\u01b5\3\2\2\2\66\u01c5\3"+
+		"\2\2\28\u01c7\3\2\2\2:\u01d3\3\2\2\2<\u01e6\3\2\2\2>\u01f4\3\2\2\2@\u01fa"+
+		"\3\2\2\2B\u01fc\3\2\2\2D\u0200\3\2\2\2F\u0206\3\2\2\2H\u020d\3\2\2\2J"+
+		"\u0217\3\2\2\2L\u021b\3\2\2\2N\u0220\3\2\2\2P\u0238\3\2\2\2R\u023a\3\2"+
+		"\2\2T\u023e\3\2\2\2V\u0246\3\2\2\2X\u0249\3\2\2\2Z\u024c\3\2\2\2\\\u0254"+
+		"\3\2\2\2^\u0261\3\2\2\2`\u0268\3\2\2\2b\u026b\3\2\2\2d\u0271\3\2\2\2f"+
+		"\u0277\3\2\2\2h\u027b\3\2\2\2j\u027f\3\2\2\2l\u0284\3\2\2\2n\u0288\3\2"+
+		"\2\2p\u0291\3\2\2\2r\u029c\3\2\2\2t\u02a0\3\2\2\2v\u02a2\3\2\2\2x\u02a4"+
+		"\3\2\2\2z\u02af\3\2\2\2|\u02b4\3\2\2\2~\u02c4\3\2\2\2\u0080\u02d7\3\2"+
+		"\2\2\u0082\u02db\3\2\2\2\u0084\u02dd\3\2\2\2\u0086\u02eb\3\2\2\2\u0088"+
+		"\u02fd\3\2\2\2\u008a\u0302\3\2\2\2\u008c\u030a\3\2\2\2\u008e\u031d\3\2"+
+		"\2\2\u0090\u0322\3\2\2\2\u0092\u032c\3\2\2\2\u0094\u032f\3\2\2\2\u0096"+
+		"\u0339\3\2\2\2\u0098\u033d\3\2\2\2\u009a\u033f\3\2\2\2\u009c\u0341\3\2"+
+		"\2\2\u009e\u0347\3\2\2\2\u00a0\u0354\3\2\2\2\u00a2\u0357\3\2\2\2\u00a4"+
+		"\u0360\3\2\2\2\u00a6\u0362\3\2\2\2\u00a8\u0399\3\2\2\2\u00aa\u039e\3\2"+
+		"\2\2\u00ac\u03a8\3\2\2\2\u00ae\u03b4\3\2\2\2\u00b0\u03bf\3\2\2\2\u00b2"+
+		"\u03cd\3\2\2\2\u00b4\u03cf\3\2\2\2\u00b6\u03d6\3\2\2\2\u00b8\u03df\3\2"+
+		"\2\2\u00ba\u03e4\3\2\2\2\u00bc\u03e9\3\2\2\2\u00be\u03ef\3\2\2\2\u00c0"+
+		"\u03f4\3\2\2\2\u00c2\u0408\3\2\2\2\u00c4\u040a\3\2\2\2\u00c6\u040d\3\2"+
+		"\2\2\u00c8\u041b\3\2\2\2\u00ca\u0420\3\2\2\2\u00cc\u042f\3\2\2\2\u00ce"+
+		"\u0434\3\2\2\2\u00d0\u0440\3\2\2\2\u00d2\u0445\3\2\2\2\u00d4\u044d\3\2"+
+		"\2\2\u00d6\u0458\3\2\2\2\u00d8\u045a\3\2\2\2\u00da\u0462\3\2\2\2\u00dc"+
+		"\u046a\3\2\2\2\u00de\u0471\3\2\2\2\u00e0\u0473\3\2\2\2\u00e2\u047c\3\2"+
+		"\2\2\u00e4\u0484\3\2\2\2\u00e6\u0487\3\2\2\2\u00e8\u048d\3\2\2\2\u00ea"+
+		"\u0496\3\2\2\2\u00ec\u049e\3\2\2\2\u00ee\u04a5\3\2\2\2\u00f0\u00f2\5\u00d6"+
+		"l\2\u00f1\u00f0\3\2\2\2\u00f2\u00f5\3\2\2\2\u00f3\u00f1\3\2\2\2\u00f3"+
+		"\u00f4\3\2\2\2\u00f4\u00f6\3\2\2\2\u00f5\u00f3\3\2\2\2\u00f6\u00ff\5\4"+
+		"\3\2\u00f7\u00f9\5\u00d6l\2\u00f8\u00f7\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa"+
+		"\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb\u00fd\3\2\2\2\u00fc\u00fa\3\2"+
+		"\2\2\u00fd\u00ff\7\5\2\2\u00fe\u00f3\3\2\2\2\u00fe\u00fa\3\2\2\2\u00ff"+
+		"\3\3\2\2\2\u0100\u0103\5\6\4\2\u0101\u0103\5\b\5\2\u0102\u0100\3\2\2\2"+
+		"\u0102\u0101\3\2\2\2\u0103\5\3\2\2\2\u0104\u0105\t\2\2\2\u0105\7\3\2\2"+
+		"\2\u0106\u0107\t\3\2\2\u0107\t\3\2\2\2\u0108\u010c\5\f\7\2\u0109\u010c"+
+		"\5\32\16\2\u010a\u010c\5\34\17\2\u010b\u0108\3\2\2\2\u010b\u0109\3\2\2"+
+		"\2\u010b\u010a\3\2\2\2\u010c\13\3\2\2\2\u010d\u0110\5\22\n\2\u010e\u0110"+
+		"\5\30\r\2\u010f\u010d\3\2\2\2\u010f\u010e\3\2\2\2\u0110\u0115\3\2\2\2"+
+		"\u0111\u0114\5\20\t\2\u0112\u0114\5\26\f\2\u0113\u0111\3\2\2\2\u0113\u0112"+
+		"\3\2\2\2\u0114\u0117\3\2\2\2\u0115\u0113\3\2\2\2\u0115\u0116\3\2\2\2\u0116"+
+		"\r\3\2\2\2\u0117\u0115\3\2\2\2\u0118\u011a\5\u00d6l\2\u0119\u0118\3\2"+
+		"\2\2\u011a\u011d\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011c\3\2\2\2\u011c"+
+		"\u011e\3\2\2\2\u011d\u011b\3\2\2\2\u011e\u0120\7h\2\2\u011f\u0121\5(\25"+
+		"\2\u0120\u011f\3\2\2\2\u0120\u0121\3\2\2\2\u0121\u012f\3\2\2\2\u0122\u0123"+
+		"\5\f\7\2\u0123\u0127\7C\2\2\u0124\u0126\5\u00d6l\2\u0125\u0124\3\2\2\2"+
+		"\u0126\u0129\3\2\2\2\u0127\u0125\3\2\2\2\u0127\u0128\3\2\2\2\u0128\u012a"+
+		"\3\2\2\2\u0129\u0127\3\2\2\2\u012a\u012c\7h\2\2\u012b\u012d\5(\25\2\u012c"+
+		"\u012b\3\2\2\2\u012c\u012d\3\2\2\2\u012d\u012f\3\2\2\2\u012e\u011b\3\2"+
+		"\2\2\u012e\u0122\3\2\2\2\u012f\17\3\2\2\2\u0130\u0134\7C\2\2\u0131\u0133"+
+		"\5\u00d6l\2\u0132\u0131\3\2\2\2\u0133\u0136\3\2\2\2\u0134\u0132\3\2\2"+
+		"\2\u0134\u0135\3\2\2\2\u0135\u0137\3\2\2\2\u0136\u0134\3\2\2\2\u0137\u0139"+
+		"\7h\2\2\u0138\u013a\5(\25\2\u0139\u0138\3\2\2\2\u0139\u013a\3\2\2\2\u013a"+
+		"\21\3\2\2\2\u013b\u013d\5\u00d6l\2\u013c\u013b\3\2\2\2\u013d\u0140\3\2"+
+		"\2\2\u013e\u013c\3\2\2\2\u013e\u013f\3\2\2\2\u013f\u0141\3\2\2\2\u0140"+
+		"\u013e\3\2\2\2\u0141\u0143\7h\2\2\u0142\u0144\5(\25\2\u0143\u0142\3\2"+
+		"\2\2\u0143\u0144\3\2\2\2\u0144\23\3\2\2\2\u0145\u0146\5\16\b\2\u0146\25"+
+		"\3\2\2\2\u0147\u0148\5\20\t\2\u0148\27\3\2\2\2\u0149\u014a\5\22\n\2\u014a"+
+		"\31\3\2\2\2\u014b\u014d\5\u00d6l\2\u014c\u014b\3\2\2\2\u014d\u0150\3\2"+
+		"\2\2\u014e\u014c\3\2\2\2\u014e\u014f\3\2\2\2\u014f\u0151\3\2\2\2\u0150"+
+		"\u014e\3\2\2\2\u0151\u0152\7h\2\2\u0152\33\3\2\2\2\u0153\u0154\5\2\2\2"+
+		"\u0154\u0155\5\36\20\2\u0155\u015d\3\2\2\2\u0156\u0157\5\f\7\2\u0157\u0158"+
+		"\5\36\20\2\u0158\u015d\3\2\2\2\u0159\u015a\5\32\16\2\u015a\u015b\5\36"+
+		"\20\2\u015b\u015d\3\2\2\2\u015c\u0153\3\2\2\2\u015c\u0156\3\2\2\2\u015c"+
+		"\u0159\3\2\2\2\u015d\35\3\2\2\2\u015e\u0160\5\u00d6l\2\u015f\u015e\3\2"+
+		"\2\2\u0160\u0163\3\2\2\2\u0161\u015f\3\2\2\2\u0161\u0162\3\2\2\2\u0162"+
+		"\u0164\3\2\2\2\u0163\u0161\3\2\2\2\u0164\u0165\7?\2\2\u0165\u0170\7@\2"+
+		"\2\u0166\u0168\5\u00d6l\2\u0167\u0166\3\2\2\2\u0168\u016b\3\2\2\2\u0169"+
+		"\u0167\3\2\2\2\u0169\u016a\3\2\2\2\u016a\u016c\3\2\2\2\u016b\u0169\3\2"+
+		"\2\2\u016c\u016d\7?\2\2\u016d\u016f\7@\2\2\u016e\u0169\3\2\2\2\u016f\u0172"+
+		"\3\2\2\2\u0170\u016e\3\2\2\2\u0170\u0171\3\2\2\2\u0171\37\3\2\2\2\u0172"+
+		"\u0170\3\2\2\2\u0173\u0175\5\"\22\2\u0174\u0173\3\2\2\2\u0175\u0178\3"+
+		"\2\2\2\u0176\u0174\3\2\2\2\u0176\u0177\3\2\2\2\u0177\u0179\3\2\2\2\u0178"+
+		"\u0176\3\2\2\2\u0179\u017b\7h\2\2\u017a\u017c\5$\23\2\u017b\u017a\3\2"+
+		"\2\2\u017b\u017c\3\2\2\2\u017c!\3\2\2\2\u017d\u017e\5\u00d6l\2\u017e#"+
+		"\3\2\2\2\u017f\u0180\7\23\2\2\u0180\u018a\5\32\16\2\u0181\u0182\7\23\2"+
+		"\2\u0182\u0186\5\f\7\2\u0183\u0185\5&\24\2\u0184\u0183\3\2\2\2\u0185\u0188"+
+		"\3\2\2\2\u0186\u0184\3\2\2\2\u0186\u0187\3\2\2\2\u0187\u018a\3\2\2\2\u0188"+
+		"\u0186\3\2\2\2\u0189\u017f\3\2\2\2\u0189\u0181\3\2\2\2\u018a%\3\2\2\2"+
+		"\u018b\u018c\7W\2\2\u018c\u018d\5\24\13\2\u018d\'\3\2\2\2\u018e\u018f"+
+		"\7F\2\2\u018f\u0190\5*\26\2\u0190\u0191\7E\2\2\u0191)\3\2\2\2\u0192\u0197"+
+		"\5,\27\2\u0193\u0194\7B\2\2\u0194\u0196\5,\27\2\u0195\u0193\3\2\2\2\u0196"+
+		"\u0199\3\2\2\2\u0197\u0195\3\2\2\2\u0197\u0198\3\2\2\2\u0198+\3\2\2\2"+
+		"\u0199\u0197\3\2\2\2\u019a\u019d\5\n\6\2\u019b\u019d\5.\30\2\u019c\u019a"+
+		"\3\2\2\2\u019c\u019b\3\2\2\2\u019d-\3\2\2\2\u019e\u01a0\5\u00d6l\2\u019f"+
+		"\u019e\3\2\2\2\u01a0\u01a3\3\2\2\2\u01a1\u019f\3\2\2\2\u01a1\u01a2\3\2"+
+		"\2\2\u01a2\u01a4\3\2\2\2\u01a3\u01a1\3\2\2\2\u01a4\u01a6\7I\2\2\u01a5"+
+		"\u01a7\5\60\31\2\u01a6\u01a5\3\2\2\2\u01a6\u01a7\3\2\2\2\u01a7/\3\2\2"+
+		"\2\u01a8\u01a9\7\23\2\2\u01a9\u01ad\5\n\6\2\u01aa\u01ab\7*\2\2\u01ab\u01ad"+
+		"\5\n\6\2\u01ac\u01a8\3\2\2\2\u01ac\u01aa\3\2\2\2\u01ad\61\3\2\2\2\u01ae"+
+		"\u01b4\7h\2\2\u01af\u01b0\5\64\33\2\u01b0\u01b1\7C\2\2\u01b1\u01b2\7h"+
+		"\2\2\u01b2\u01b4\3\2\2\2\u01b3\u01ae\3\2\2\2\u01b3\u01af\3\2\2\2\u01b4"+
+		"\63\3\2\2\2\u01b5\u01b6\b\33\1\2\u01b6\u01b7\7h\2\2\u01b7\u01bd\3\2\2"+
+		"\2\u01b8\u01b9\f\3\2\2\u01b9\u01ba\7C\2\2\u01ba\u01bc\7h\2\2\u01bb\u01b8"+
+		"\3\2\2\2\u01bc\u01bf\3\2\2\2\u01bd\u01bb\3\2\2\2\u01bd\u01be\3\2\2\2\u01be"+
+		"\65\3\2\2\2\u01bf\u01bd\3\2\2\2\u01c0\u01c6\7h\2\2\u01c1\u01c2\58\35\2"+
+		"\u01c2\u01c3\7C\2\2\u01c3\u01c4\7h\2\2\u01c4\u01c6\3\2\2\2\u01c5\u01c0"+
+		"\3\2\2\2\u01c5\u01c1\3\2\2\2\u01c6\67\3\2\2\2\u01c7\u01c8\b\35\1\2\u01c8"+
+		"\u01c9\7h\2\2\u01c9\u01cf\3\2\2\2\u01ca\u01cb\f\3\2\2\u01cb\u01cc\7C\2"+
+		"\2\u01cc\u01ce\7h\2\2\u01cd\u01ca\3\2\2\2\u01ce\u01d1\3\2\2\2\u01cf\u01cd"+
+		"\3\2\2\2\u01cf\u01d0\3\2\2\2\u01d09\3\2\2\2\u01d1\u01cf\3\2\2\2\u01d2"+
+		"\u01d4\5<\37\2\u01d3\u01d2\3\2\2\2\u01d3\u01d4\3\2\2\2\u01d4\u01d8\3\2"+
+		"\2\2\u01d5\u01d7\5@!\2\u01d6\u01d5\3\2\2\2\u01d7\u01da\3\2\2\2\u01d8\u01d6"+
+		"\3\2\2\2\u01d8\u01d9\3\2\2\2\u01d9\u01de\3\2\2\2\u01da\u01d8\3\2\2\2\u01db"+
+		"\u01dd\5J&\2\u01dc\u01db\3\2\2\2\u01dd\u01e0\3\2\2\2\u01de\u01dc\3\2\2"+
+		"\2\u01de\u01df\3\2\2\2\u01df\u01e1\3\2\2\2\u01e0\u01de\3\2\2\2\u01e1\u01e2"+
+		"\7\2\2\3\u01e2;\3\2\2\2\u01e3\u01e5\5> \2\u01e4\u01e3\3\2\2\2\u01e5\u01e8"+
+		"\3\2\2\2\u01e6\u01e4\3\2\2\2\u01e6\u01e7\3\2\2\2\u01e7\u01e9\3\2\2\2\u01e8"+
+		"\u01e6\3\2\2\2\u01e9\u01ea\7\"\2\2\u01ea\u01ef\7h\2\2\u01eb\u01ec\7C\2"+
+		"\2\u01ec\u01ee\7h\2\2\u01ed\u01eb\3\2\2\2\u01ee\u01f1\3\2\2\2\u01ef\u01ed"+
+		"\3\2\2\2\u01ef\u01f0\3\2\2\2\u01f0\u01f2\3\2\2\2\u01f1\u01ef\3\2\2\2\u01f2"+
+		"\u01f3\7A\2\2\u01f3=\3\2\2\2\u01f4\u01f5\5\u00d6l\2\u01f5?\3\2\2\2\u01f6"+
+		"\u01fb\5B\"\2\u01f7\u01fb\5D#\2\u01f8\u01fb\5F$\2\u01f9\u01fb\5H%\2\u01fa"+
+		"\u01f6\3\2\2\2\u01fa\u01f7\3\2\2\2\u01fa\u01f8\3\2\2\2\u01fa\u01f9\3\2"+
+		"\2\2\u01fbA\3\2\2\2\u01fc\u01fd\7\33\2\2\u01fd\u01fe\5\62\32\2\u01fe\u01ff"+
+		"\7A\2\2\u01ffC\3\2\2\2\u0200\u0201\7\33\2\2\u0201\u0202\5\64\33\2\u0202"+
+		"\u0203\7C\2\2\u0203\u0204\7U\2\2\u0204\u0205\7A\2\2\u0205E\3\2\2\2\u0206"+
+		"\u0207\7\33\2\2\u0207\u0208\7(\2\2\u0208\u0209\5\62\32\2\u0209\u020a\7"+
+		"C\2\2\u020a\u020b\7h\2\2\u020b\u020c\7A\2\2\u020cG\3\2\2\2\u020d\u020e"+
+		"\7\33\2\2\u020e\u020f\7(\2\2\u020f\u0210\5\62\32\2\u0210\u0211\7C\2\2"+
+		"\u0211\u0212\7U\2\2\u0212\u0213\7A\2\2\u0213I\3\2\2\2\u0214\u0218\5L\'"+
+		"\2\u0215\u0218\5\u00be`\2\u0216\u0218\7A\2\2\u0217\u0214\3\2\2\2\u0217"+
+		"\u0215\3\2\2\2\u0217\u0216\3\2\2\2\u0218K\3\2\2\2\u0219\u021c\5N(\2\u021a"+
+		"\u021c\5\u00aaV\2\u021b\u0219\3\2\2\2\u021b\u021a\3\2\2\2\u021cM\3\2\2"+
+		"\2\u021d\u021f\5P)\2\u021e\u021d\3\2\2\2\u021f\u0222\3\2\2\2\u0220\u021e"+
+		"\3\2\2\2\u0220\u0221\3\2\2\2\u0221\u0223\3\2\2\2\u0222\u0220\3\2\2\2\u0223"+
+		"\u0224\7\13\2\2\u0224\u0226\7h\2\2\u0225\u0227\5R*\2\u0226\u0225\3\2\2"+
+		"\2\u0226\u0227\3\2\2\2\u0227\u0229\3\2\2\2\u0228\u022a\5V,\2\u0229\u0228"+
+		"\3\2\2\2\u0229\u022a\3\2\2\2\u022a\u022c\3\2\2\2\u022b\u022d\5X-\2\u022c"+
+		"\u022b\3\2\2\2\u022c\u022d\3\2\2\2\u022d\u022e\3\2\2\2\u022e\u022f\5\\"+
+		"/\2\u022fO\3\2\2\2\u0230\u0239\5\u00d6l\2\u0231\u0239\7%\2\2\u0232\u0239"+
+		"\7$\2\2\u0233\u0239\7#\2\2\u0234\u0239\7\3\2\2\u0235\u0239\7(\2\2\u0236"+
+		"\u0239\7\24\2\2\u0237\u0239\7)\2\2\u0238\u0230\3\2\2\2\u0238\u0231\3\2"+
+		"\2\2\u0238\u0232\3\2\2\2\u0238\u0233\3\2\2\2\u0238\u0234\3\2\2\2\u0238"+
+		"\u0235\3\2\2\2\u0238\u0236\3\2\2\2\u0238\u0237\3\2\2\2\u0239Q\3\2\2\2"+
+		"\u023a\u023b\7F\2\2\u023b\u023c\5T+\2\u023c\u023d\7E\2\2\u023dS\3\2\2"+
+		"\2\u023e\u0243\5 \21\2\u023f\u0240\7B\2\2\u0240\u0242\5 \21\2\u0241\u023f"+
+		"\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243\u0244\3\2\2\2\u0244"+
+		"U\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\7\23\2\2\u0247\u0248\5\16\b"+
+		"\2\u0248W\3\2\2\2\u0249\u024a\7\32\2\2\u024a\u024b\5Z.\2\u024bY\3\2\2"+
+		"\2\u024c\u0251\5\24\13\2\u024d\u024e\7B\2\2\u024e\u0250\5\24\13\2\u024f"+
+		"\u024d\3\2\2\2\u0250\u0253\3\2\2\2\u0251\u024f\3\2\2\2\u0251\u0252\3\2"+
+		"\2\2\u0252[\3\2\2\2\u0253\u0251\3\2\2\2\u0254\u0258\7=\2\2\u0255\u0257"+
+		"\5^\60\2\u0256\u0255\3\2\2\2\u0257\u025a\3\2\2\2\u0258\u0256\3\2\2\2\u0258"+
+		"\u0259\3\2\2\2\u0259\u025b\3\2\2\2\u025a\u0258\3\2\2\2\u025b\u025c\7>"+
+		"\2\2\u025c]\3\2\2\2\u025d\u0262\5`\61\2\u025e\u0262\5\u009aN\2\u025f\u0262"+
+		"\5\u009cO\2\u0260\u0262\5\u009eP\2\u0261\u025d\3\2\2\2\u0261\u025e\3\2"+
+		"\2\2\u0261\u025f\3\2\2\2\u0261\u0260\3\2\2\2\u0262_\3\2\2\2\u0263\u0269"+
+		"\5b\62\2\u0264\u0269\5|?\2\u0265\u0269\5L\'\2\u0266\u0269\5\u00be`\2\u0267"+
+		"\u0269\7A\2\2\u0268\u0263\3\2\2\2\u0268\u0264\3\2\2\2\u0268\u0265\3\2"+
+		"\2\2\u0268\u0266\3\2\2\2\u0268\u0267\3\2\2\2\u0269a\3\2\2\2\u026a\u026c"+
+		"\13\2\2\2\u026b\u026a\3\2\2\2\u026c\u026d\3\2\2\2\u026d\u026e\3\2\2\2"+
+		"\u026d\u026b\3\2\2\2\u026e\u026f\3\2\2\2\u026f\u0270\7A\2\2\u0270c\3\2"+
+		"\2\2\u0271\u0273\7h\2\2\u0272\u0274\5\36\20\2\u0273\u0272\3\2\2\2\u0273"+
+		"\u0274\3\2\2\2\u0274e\3\2\2\2\u0275\u0278\5\u00b8]\2\u0276\u0278\5\u00e8"+
+		"u\2\u0277\u0275\3\2\2\2\u0277\u0276\3\2\2\2\u0278g\3\2\2\2\u0279\u027c"+
+		"\5j\66\2\u027a\u027c\5l\67\2\u027b\u0279\3\2\2\2\u027b\u027a\3\2\2\2\u027c"+
+		"i\3\2\2\2\u027d\u0280\5\4\3\2\u027e\u0280\7\5\2\2\u027f\u027d\3\2\2\2"+
+		"\u027f\u027e\3\2\2\2\u0280k\3\2\2\2\u0281\u0285\5n8\2\u0282\u0285\5x="+
+		"\2\u0283\u0285\5z>\2\u0284\u0281\3\2\2\2\u0284\u0282\3\2\2\2\u0284\u0283"+
+		"\3\2\2\2\u0285m\3\2\2\2\u0286\u0289\5r:\2\u0287\u0289\5v<\2\u0288\u0286"+
+		"\3\2\2\2\u0288\u0287\3\2\2\2\u0289\u028e\3\2\2\2\u028a\u028d\5p9\2\u028b"+
+		"\u028d\5t;\2\u028c\u028a\3\2\2\2\u028c\u028b\3\2\2\2\u028d\u0290\3\2\2"+
+		"\2\u028e\u028c\3\2\2\2\u028e\u028f\3\2\2\2\u028fo\3\2\2\2\u0290\u028e"+
+		"\3\2\2\2\u0291\u0295\7C\2\2\u0292\u0294\5\u00d6l\2\u0293\u0292\3\2\2\2"+
+		"\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296\u0298"+
+		"\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u029a\7h\2\2\u0299\u029b\5(\25\2\u029a"+
+		"\u0299\3\2\2\2\u029a\u029b\3\2\2\2\u029bq\3\2\2\2\u029c\u029e\7h\2\2\u029d"+
+		"\u029f\5(\25\2\u029e\u029d\3\2\2\2\u029e\u029f\3\2\2\2\u029fs\3\2\2\2"+
+		"\u02a0\u02a1\5p9\2\u02a1u\3\2\2\2\u02a2\u02a3\5r:\2\u02a3w\3\2\2\2\u02a4"+
+		"\u02a5\7h\2\2\u02a5y\3\2\2\2\u02a6\u02a7\5j\66\2\u02a7\u02a8\5\36\20\2"+
+		"\u02a8\u02b0\3\2\2\2\u02a9\u02aa\5n8\2\u02aa\u02ab\5\36\20\2\u02ab\u02b0"+
+		"\3\2\2\2\u02ac\u02ad\5x=\2\u02ad\u02ae\5\36\20\2\u02ae\u02b0\3\2\2\2\u02af"+
+		"\u02a6\3\2\2\2\u02af\u02a9\3\2\2\2\u02af\u02ac\3\2\2\2\u02b0{\3\2\2\2"+
+		"\u02b1\u02b3\5~@\2\u02b2\u02b1\3\2\2\2\u02b3\u02b6\3\2\2\2\u02b4\u02b2"+
+		"\3\2\2\2\u02b4\u02b5\3\2\2\2\u02b5\u02b7\3\2\2\2\u02b6\u02b4\3\2\2\2\u02b7"+
+		"\u02b8\5\u0080A\2\u02b8\u02b9\5\u0098M\2\u02b9}\3\2\2\2\u02ba\u02c5\5"+
+		"\u00d6l\2\u02bb\u02c5\7%\2\2\u02bc\u02c5\7$\2\2\u02bd\u02c5\7#\2\2\u02be"+
+		"\u02c5\7\3\2\2\u02bf\u02c5\7(\2\2\u02c0\u02c5\7\24\2\2\u02c1\u02c5\7,"+
+		"\2\2\u02c2\u02c5\7 \2\2\u02c3\u02c5\7)\2\2\u02c4\u02ba\3\2\2\2\u02c4\u02bb"+
+		"\3\2\2\2\u02c4\u02bc\3\2\2\2\u02c4\u02bd\3\2\2\2\u02c4\u02be\3\2\2\2\u02c4"+
+		"\u02bf\3\2\2\2\u02c4\u02c0\3\2\2\2\u02c4\u02c1\3\2\2\2\u02c4\u02c2\3\2"+
+		"\2\2\u02c4\u02c3\3\2\2\2\u02c5\177\3\2\2\2\u02c6\u02c7\5\u0082B\2\u02c7"+
+		"\u02c9\5\u0084C\2\u02c8\u02ca\5\u0092J\2\u02c9\u02c8\3\2\2\2\u02c9\u02ca"+
+		"\3\2\2\2\u02ca\u02d8\3\2\2\2\u02cb\u02cf\5R*\2\u02cc\u02ce\5\u00d6l\2"+
+		"\u02cd\u02cc\3\2\2\2\u02ce\u02d1\3\2\2\2\u02cf\u02cd\3\2\2\2\u02cf\u02d0"+
+		"\3\2\2\2\u02d0\u02d2\3\2\2\2\u02d1\u02cf\3\2\2\2\u02d2\u02d3\5\u0082B"+
+		"\2\u02d3\u02d5\5\u0084C\2\u02d4\u02d6\5\u0092J\2\u02d5\u02d4\3\2\2\2\u02d5"+
+		"\u02d6\3\2\2\2\u02d6\u02d8\3\2\2\2\u02d7\u02c6\3\2\2\2\u02d7\u02cb\3\2"+
+		"\2\2\u02d8\u0081\3\2\2\2\u02d9\u02dc\5h\65\2\u02da\u02dc\7\62\2\2\u02db"+
+		"\u02d9\3\2\2\2\u02db\u02da\3\2\2\2\u02dc\u0083\3\2\2\2\u02dd\u02de\7h"+
+		"\2\2\u02de\u02e0\7;\2\2\u02df\u02e1\5\u0086D\2\u02e0\u02df\3\2\2\2\u02e0"+
+		"\u02e1\3\2\2\2\u02e1\u02e2\3\2\2\2\u02e2\u02e4\7<\2\2\u02e3\u02e5\5\36"+
+		"\20\2\u02e4\u02e3\3\2\2\2\u02e4\u02e5\3\2\2\2\u02e5\u0085\3\2\2\2\u02e6"+
+		"\u02e7\5\u0088E\2\u02e7\u02e8\7B\2\2\u02e8\u02e9\5\u008eH\2\u02e9\u02ec"+
+		"\3\2\2\2\u02ea\u02ec\5\u008eH\2\u02eb\u02e6\3\2\2\2\u02eb\u02ea\3\2\2"+
+		"\2\u02ec\u0087\3\2\2\2\u02ed\u02f2\5\u008aF\2\u02ee\u02ef\7B\2\2\u02ef"+
+		"\u02f1\5\u008aF\2\u02f0\u02ee\3\2\2\2\u02f1\u02f4\3\2\2\2\u02f2\u02f0"+
+		"\3\2\2\2\u02f2\u02f3\3\2\2\2\u02f3\u02fe\3\2\2\2\u02f4\u02f2\3\2\2\2\u02f5"+
+		"\u02fa\5\u0090I\2\u02f6\u02f7\7B\2\2\u02f7\u02f9\5\u008aF\2\u02f8\u02f6"+
+		"\3\2\2\2\u02f9\u02fc\3\2\2\2\u02fa\u02f8\3\2\2\2\u02fa\u02fb\3\2\2\2\u02fb"+
+		"\u02fe\3\2\2\2\u02fc\u02fa\3\2\2\2\u02fd\u02ed\3\2\2\2\u02fd\u02f5\3\2"+
+		"\2\2\u02fe\u0089\3\2\2\2\u02ff\u0301\5\u008cG\2\u0300\u02ff\3\2\2\2\u0301"+
+		"\u0304\3\2\2\2\u0302\u0300\3\2\2\2\u0302\u0303\3\2\2\2\u0303\u0305\3\2"+
+		"\2\2\u0304\u0302\3\2\2\2\u0305\u0306\5h\65\2\u0306\u0307\5d\63\2\u0307"+
+		"\u008b\3\2\2\2\u0308\u030b\5\u00d6l\2\u0309\u030b\7\24\2\2\u030a\u0308"+
+		"\3\2\2\2\u030a\u0309\3\2\2\2\u030b\u008d\3\2\2\2\u030c\u030e\5\u008cG"+
+		"\2\u030d\u030c\3\2\2\2\u030e\u0311\3\2\2\2\u030f\u030d\3\2\2\2\u030f\u0310"+
+		"\3\2\2\2\u0310\u0312\3\2\2\2\u0311\u030f\3\2\2\2\u0312\u0316\5h\65\2\u0313"+
+		"\u0315\5\u00d6l\2\u0314\u0313\3\2\2\2\u0315\u0318\3\2\2\2\u0316\u0314"+
+		"\3\2\2\2\u0316\u0317\3\2\2\2\u0317\u0319\3\2\2\2\u0318\u0316\3\2\2\2\u0319"+
+		"\u031a\7j\2\2\u031a\u031b\5d\63\2\u031b\u031e\3\2\2\2\u031c\u031e\5\u008a"+
+		"F\2\u031d\u030f\3\2\2\2\u031d\u031c\3\2\2\2\u031e\u008f\3\2\2\2\u031f"+
+		"\u0321\5\u00d6l\2\u0320\u031f\3\2\2\2\u0321\u0324\3\2\2\2\u0322\u0320"+
+		"\3\2\2\2\u0322\u0323\3\2\2\2\u0323\u0325\3\2\2\2\u0324\u0322\3\2\2\2\u0325"+
+		"\u0328\5h\65\2\u0326\u0327\7h\2\2\u0327\u0329\7C\2\2\u0328\u0326\3\2\2"+
+		"\2\u0328\u0329\3\2\2\2\u0329\u032a\3\2\2\2\u032a\u032b\7-\2\2\u032b\u0091"+
+		"\3\2\2\2\u032c\u032d\7/\2\2\u032d\u032e\5\u0094K\2\u032e\u0093\3\2\2\2"+
+		"\u032f\u0334\5\u0096L\2\u0330\u0331\7B\2\2\u0331\u0333\5\u0096L\2\u0332"+
+		"\u0330\3\2\2\2\u0333\u0336\3\2\2\2\u0334\u0332\3\2\2\2\u0334\u0335\3\2"+
+		"\2\2\u0335\u0095\3\2\2\2\u0336\u0334\3\2\2\2\u0337\u033a\5\16\b\2\u0338"+
+		"\u033a\5\32\16\2\u0339\u0337\3\2\2\2\u0339\u0338\3\2\2\2\u033a\u0097\3"+
+		"\2\2\2\u033b\u033e\5\u00ecw\2\u033c\u033e\7A\2\2\u033d\u033b\3\2\2\2\u033d"+
+		"\u033c\3\2\2\2\u033e\u0099\3\2\2\2\u033f\u0340\5\u00ecw\2\u0340\u009b"+
+		"\3\2\2\2\u0341\u0342\7(\2\2\u0342\u0343\5\u00ecw\2\u0343\u009d\3\2\2\2"+
+		"\u0344\u0346\5\u00a0Q\2\u0345\u0344\3\2\2\2\u0346\u0349\3\2\2\2\u0347"+
+		"\u0345\3\2\2\2\u0347\u0348\3\2\2\2\u0348\u034a\3\2\2\2\u0349\u0347\3\2"+
+		"\2\2\u034a\u034c\5\u00a2R\2\u034b\u034d\5\u0092J\2\u034c\u034b\3\2\2\2"+
+		"\u034c\u034d\3\2\2\2\u034d\u034e\3\2\2\2\u034e\u034f\5\u00a6T\2\u034f"+
+		"\u009f\3\2\2\2\u0350\u0355\5\u00d6l\2\u0351\u0355\7%\2\2\u0352\u0355\7"+
+		"$\2\2\u0353\u0355\7#\2\2\u0354\u0350\3\2\2\2\u0354\u0351\3\2\2\2\u0354"+
+		"\u0352\3\2\2\2\u0354\u0353\3\2\2\2\u0355\u00a1\3\2\2\2\u0356\u0358\5R"+
+		"*\2\u0357\u0356\3\2\2\2\u0357\u0358\3\2\2\2\u0358\u0359\3\2\2\2\u0359"+
+		"\u035a\5\u00a4S\2\u035a\u035c\7;\2\2\u035b\u035d\5\u0086D\2\u035c\u035b"+
+		"\3\2\2\2\u035c\u035d\3\2\2\2\u035d\u035e\3\2\2\2\u035e\u035f\7<\2\2\u035f"+
+		"\u00a3\3\2\2\2\u0360\u0361\7h\2\2\u0361\u00a5\3\2\2\2\u0362\u0364\7=\2"+
+		"\2\u0363\u0365\5\u00a8U\2\u0364\u0363\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+
+		"\u0367\3\2\2\2\u0366\u0368\5\u00eex\2\u0367\u0366\3\2\2\2\u0367\u0368"+
+		"\3\2\2\2\u0368\u0369\3\2\2\2\u0369\u036a\7>\2\2\u036a\u00a7\3\2\2\2\u036b"+
+		"\u036d\5(\25\2\u036c\u036b\3\2\2\2\u036c\u036d\3\2\2\2\u036d\u036e\3\2"+
+		"\2\2\u036e\u036f\7-\2\2\u036f\u0371\7;\2\2\u0370\u0372\5\u00b6\\\2\u0371"+
+		"\u0370\3\2\2\2\u0371\u0372\3\2\2\2\u0372\u0373\3\2\2\2\u0373\u0374\7<"+
+		"\2\2\u0374\u039a\7A\2\2\u0375\u0377\5(\25\2\u0376\u0375\3\2\2\2\u0376"+
+		"\u0377\3\2\2\2\u0377\u0378\3\2\2\2\u0378\u0379\7*\2\2\u0379\u037b\7;\2"+
+		"\2\u037a\u037c\5\u00b6\\\2\u037b\u037a\3\2\2\2\u037b\u037c\3\2\2\2\u037c"+
+		"\u037d\3\2\2\2\u037d\u037e\7<\2\2\u037e\u039a\7A\2\2\u037f\u0380\5\66"+
+		"\34\2\u0380\u0382\7C\2\2\u0381\u0383\5(\25\2\u0382\u0381\3\2\2\2\u0382"+
+		"\u0383\3\2\2\2\u0383\u0384\3\2\2\2\u0384\u0385\7*\2\2\u0385\u0387\7;\2"+
+		"\2\u0386\u0388\5\u00b6\\\2\u0387\u0386\3\2\2\2\u0387\u0388\3\2\2\2\u0388"+
+		"\u0389\3\2\2\2\u0389\u038a\7<\2\2\u038a\u038b\7A\2\2\u038b\u039a\3\2\2"+
+		"\2\u038c\u038d\5\u00bc_\2\u038d\u038f\7C\2\2\u038e\u0390\5(\25\2\u038f"+
+		"\u038e\3\2\2\2\u038f\u0390\3\2\2\2\u0390\u0391\3\2\2\2\u0391\u0392\7*"+
+		"\2\2\u0392\u0394\7;\2\2\u0393\u0395\5\u00b6\\\2\u0394\u0393\3\2\2\2\u0394"+
+		"\u0395\3\2\2\2\u0395\u0396\3\2\2\2\u0396\u0397\7<\2\2\u0397\u0398\7A\2"+
+		"\2\u0398\u039a\3\2\2\2\u0399\u036c\3\2\2\2\u0399\u0376\3\2\2\2\u0399\u037f"+
+		"\3\2\2\2\u0399\u038c\3\2\2\2\u039a\u00a9\3\2\2\2\u039b\u039d\5P)\2\u039c"+
+		"\u039b\3\2\2\2\u039d\u03a0\3\2\2\2\u039e\u039c\3\2\2\2\u039e\u039f\3\2"+
+		"\2\2\u039f\u03a1\3\2\2\2\u03a0\u039e\3\2\2\2\u03a1\u03a2\7\22\2\2\u03a2"+
+		"\u03a4\7h\2\2\u03a3\u03a5\5X-\2\u03a4\u03a3\3\2\2\2\u03a4\u03a5\3\2\2"+
+		"\2\u03a5\u03a6\3\2\2\2\u03a6\u03a7\5\u00acW\2\u03a7\u00ab\3\2\2\2\u03a8"+
+		"\u03aa\7=\2\2\u03a9\u03ab\5\u00aeX\2\u03aa\u03a9\3\2\2\2\u03aa\u03ab\3"+
+		"\2\2\2\u03ab\u03ad\3\2\2\2\u03ac\u03ae\7B\2\2\u03ad\u03ac\3\2\2\2\u03ad"+
+		"\u03ae\3\2\2\2\u03ae\u03b0\3\2\2\2\u03af\u03b1\5\u00b4[\2\u03b0\u03af"+
+		"\3\2\2\2\u03b0\u03b1\3\2\2\2\u03b1\u03b2\3\2\2\2\u03b2\u03b3\7>\2\2\u03b3"+
+		"\u00ad\3\2\2\2\u03b4\u03b9\5\u00b0Y\2\u03b5\u03b6\7B\2\2\u03b6\u03b8\5"+
+		"\u00b0Y\2\u03b7\u03b5\3\2\2\2\u03b8\u03bb\3\2\2\2\u03b9\u03b7\3\2\2\2"+
+		"\u03b9\u03ba\3\2\2\2\u03ba\u00af\3\2\2\2\u03bb\u03b9\3\2\2\2\u03bc\u03be"+
+		"\5\u00b2Z\2\u03bd\u03bc\3\2\2\2\u03be\u03c1\3\2\2\2\u03bf\u03bd\3\2\2"+
+		"\2\u03bf\u03c0\3\2\2\2\u03c0\u03c2\3\2\2\2\u03c1\u03bf\3\2\2\2\u03c2\u03c8"+
+		"\7h\2\2\u03c3\u03c5\7;\2\2\u03c4\u03c6\5\u00b6\\\2\u03c5\u03c4\3\2\2\2"+
+		"\u03c5\u03c6\3\2\2\2\u03c6\u03c7\3\2\2\2\u03c7\u03c9\7<\2\2\u03c8\u03c3"+
+		"\3\2\2\2\u03c8\u03c9\3\2\2\2\u03c9\u03cb\3\2\2\2\u03ca\u03cc\5\\/\2\u03cb"+
+		"\u03ca\3\2\2\2\u03cb\u03cc\3\2\2\2\u03cc\u00b1\3\2\2\2\u03cd\u03ce\5\u00d6"+
+		"l\2\u03ce\u00b3\3\2\2\2\u03cf\u03d3\7A\2\2\u03d0\u03d2\5^\60\2\u03d1\u03d0"+
+		"\3\2\2\2\u03d2\u03d5\3\2\2\2\u03d3\u03d1\3\2\2\2\u03d3\u03d4\3\2\2\2\u03d4"+
+		"\u00b5\3\2\2\2\u03d5\u03d3\3\2\2\2\u03d6\u03db\5\u00b8]\2\u03d7\u03d8"+
+		"\7B\2\2\u03d8\u03da\5\u00b8]\2\u03d9\u03d7\3\2\2\2\u03da\u03dd\3\2\2\2"+
+		"\u03db\u03d9\3\2\2\2\u03db\u03dc\3\2\2\2\u03dc\u00b7\3\2\2\2\u03dd\u03db"+
+		"\3\2\2\2\u03de\u03e0\13\2\2\2\u03df\u03de\3\2\2\2\u03e0\u03e1\3\2\2\2"+
+		"\u03e1\u03e2\3\2\2\2\u03e1\u03df\3\2\2\2\u03e2\u00b9\3\2\2\2\u03e3\u03e5"+
+		"\13\2\2\2\u03e4\u03e3\3\2\2\2\u03e5\u03e6\3\2\2\2\u03e6\u03e7\3\2\2\2"+
+		"\u03e6\u03e4\3\2\2\2\u03e7\u00bb\3\2\2\2\u03e8\u03ea\13\2\2\2\u03e9\u03e8"+
+		"\3\2\2\2\u03ea\u03eb\3\2\2\2\u03eb\u03ec\3\2\2\2\u03eb\u03e9\3\2\2\2\u03ec"+
+		"\u00bd\3\2\2\2\u03ed\u03f0\5\u00c0a\2\u03ee\u03f0\5\u00d2j\2\u03ef\u03ed"+
+		"\3\2\2\2\u03ef\u03ee\3\2\2\2\u03f0\u00bf\3\2\2\2\u03f1\u03f3\5\u00c2b"+
+		"\2\u03f2\u03f1\3\2\2\2\u03f3\u03f6\3\2\2\2\u03f4\u03f2\3\2\2\2\u03f4\u03f5"+
+		"\3\2\2\2\u03f5\u03f7\3\2\2\2\u03f6\u03f4\3\2\2\2\u03f7\u03f8\7\36\2\2"+
+		"\u03f8\u03fa\7h\2\2\u03f9\u03fb\5R*\2\u03fa\u03f9\3\2\2\2\u03fa\u03fb"+
+		"\3\2\2\2\u03fb\u03fd\3\2\2\2\u03fc\u03fe\5\u00c4c\2\u03fd\u03fc\3\2\2"+
+		"\2\u03fd\u03fe\3\2\2\2\u03fe\u03ff\3\2\2\2\u03ff\u0400\5\u00c6d\2\u0400"+
+		"\u00c1\3\2\2\2\u0401\u0409\5\u00d6l\2\u0402\u0409\7%\2\2\u0403\u0409\7"+
+		"$\2\2\u0404\u0409\7#\2\2\u0405\u0409\7\3\2\2\u0406\u0409\7(\2\2\u0407"+
+		"\u0409\7)\2\2\u0408\u0401\3\2\2\2\u0408\u0402\3\2\2\2\u0408\u0403\3\2"+
+		"\2\2\u0408\u0404\3\2\2\2\u0408\u0405\3\2\2\2\u0408\u0406\3\2\2\2\u0408"+
+		"\u0407\3\2\2\2\u0409\u00c3\3\2\2\2\u040a\u040b\7\23\2\2\u040b\u040c\5"+
+		"Z.\2\u040c\u00c5\3\2\2\2\u040d\u0411\7=\2\2\u040e\u0410\5\u00c8e\2\u040f"+
+		"\u040e\3\2\2\2\u0410\u0413\3\2\2\2\u0411\u040f\3\2\2\2\u0411\u0412\3\2"+
+		"\2\2\u0412\u0414\3\2\2\2\u0413\u0411\3\2\2\2\u0414\u0415\7>\2\2\u0415"+
+		"\u00c7\3\2\2\2\u0416\u041c\5\u00caf\2\u0417\u041c\5\u00ceh\2\u0418\u041c"+
+		"\5L\'\2\u0419\u041c\5\u00be`\2\u041a\u041c\7A\2\2\u041b\u0416\3\2\2\2"+
+		"\u041b\u0417\3\2\2\2\u041b\u0418\3\2\2\2\u041b\u0419\3\2\2\2\u041b\u041a"+
+		"\3\2\2\2\u041c\u00c9\3\2\2\2\u041d\u041f\5\u00ccg\2\u041e\u041d\3\2\2"+
+		"\2\u041f\u0422\3\2\2\2\u0420\u041e\3\2\2\2\u0420\u0421\3\2\2\2\u0421\u0423"+
+		"\3\2\2\2\u0422\u0420\3\2\2\2\u0423\u0425\5h\65\2\u0424\u0426\13\2\2\2"+
+		"\u0425\u0424\3\2\2\2\u0426\u0427\3\2\2\2\u0427\u0428\3\2\2\2\u0427\u0425"+
+		"\3\2\2\2\u0428\u0429\3\2\2\2\u0429\u042a\7A\2\2\u042a\u00cb\3\2\2\2\u042b"+
+		"\u0430\5\u00d6l\2\u042c\u0430\7%\2\2\u042d\u0430\7(\2\2\u042e\u0430\7"+
+		"\24\2\2\u042f\u042b\3\2\2\2\u042f\u042c\3\2\2\2\u042f\u042d\3\2\2\2\u042f"+
+		"\u042e\3\2\2\2\u0430\u00cd\3\2\2\2\u0431\u0433\5\u00d0i\2\u0432\u0431"+
+		"\3\2\2\2\u0433\u0436\3\2\2\2\u0434\u0432\3\2\2\2\u0434\u0435\3\2\2\2\u0435"+
+		"\u0437\3\2\2\2\u0436\u0434\3\2\2\2\u0437\u0438\5\u0080A\2\u0438\u0439"+
+		"\5\u0098M\2\u0439\u00cf\3\2\2\2\u043a\u0441\5\u00d6l\2\u043b\u0441\7%"+
+		"\2\2\u043c\u0441\7\3\2\2\u043d\u0441\7\16\2\2\u043e\u0441\7(\2\2\u043f"+
+		"\u0441\7)\2\2\u0440\u043a\3\2\2\2\u0440\u043b\3\2\2\2\u0440\u043c\3\2"+
+		"\2\2\u0440\u043d\3\2\2\2\u0440\u043e\3\2\2\2\u0440\u043f\3\2\2\2\u0441"+
+		"\u00d1\3\2\2\2\u0442\u0444\5\u00c2b\2\u0443\u0442\3\2\2\2\u0444\u0447"+
+		"\3\2\2\2\u0445\u0443\3\2\2\2\u0445\u0446\3\2\2\2\u0446\u0448\3\2\2\2\u0447"+
+		"\u0445\3\2\2\2\u0448\u0449\7i\2\2\u0449\u044a\7\36\2\2\u044a\u044b\7h"+
+		"\2\2\u044b\u044c\5\u00d4k\2\u044c\u00d3\3\2\2\2\u044d\u044f\7=\2\2\u044e"+
+		"\u0450\13\2\2\2\u044f\u044e\3\2\2\2\u0450\u0451\3\2\2\2\u0451\u0452\3"+
+		"\2\2\2\u0451\u044f\3\2\2\2\u0452\u0453\3\2\2\2\u0453\u0454\7>\2\2\u0454"+
+		"\u00d5\3\2\2\2\u0455\u0459\5\u00d8m\2\u0456\u0459\5\u00e4s\2\u0457\u0459"+
+		"\5\u00e6t\2\u0458\u0455\3\2\2\2\u0458\u0456\3\2\2\2\u0458\u0457\3\2\2"+
+		"\2\u0459\u00d7\3\2\2\2\u045a\u045b\7i\2\2\u045b\u045c\5\62\32\2\u045c"+
+		"\u045e\7;\2\2\u045d\u045f\5\u00dan\2\u045e\u045d\3\2\2\2\u045e\u045f\3"+
+		"\2\2\2\u045f\u0460\3\2\2\2\u0460\u0461\7<\2\2\u0461\u00d9\3\2\2\2\u0462"+
+		"\u0467\5\u00dco\2\u0463\u0464\7B\2\2\u0464\u0466\5\u00dco\2\u0465\u0463"+
+		"\3\2\2\2\u0466\u0469\3\2\2\2\u0467\u0465\3\2\2\2\u0467\u0468\3\2\2\2\u0468"+
+		"\u00db\3\2\2\2\u0469\u0467\3\2\2\2\u046a\u046b\7h\2\2\u046b\u046c\7D\2"+
+		"\2\u046c\u046d\5\u00dep\2\u046d\u00dd\3\2\2\2\u046e\u0472\5\u00ba^\2\u046f"+
+		"\u0472\5\u00e0q\2\u0470\u0472\5\u00d6l\2\u0471\u046e\3\2\2\2\u0471\u046f"+
+		"\3\2\2\2\u0471\u0470\3\2\2\2\u0472\u00df\3\2\2\2\u0473\u0475\7=\2\2\u0474"+
+		"\u0476\5\u00e2r\2\u0475\u0474\3\2\2\2\u0475\u0476\3\2\2\2\u0476\u0478"+
+		"\3\2\2\2\u0477\u0479\7B\2\2\u0478\u0477\3\2\2\2\u0478\u0479\3\2\2\2\u0479"+
+		"\u047a\3\2\2\2\u047a\u047b\7>\2\2\u047b\u00e1\3\2\2\2\u047c\u0481\5\u00de"+
+		"p\2\u047d\u047e\7B\2\2\u047e\u0480\5\u00dep\2\u047f\u047d\3\2\2\2\u0480"+
+		"\u0483\3\2\2\2\u0481\u047f\3\2\2\2\u0481\u0482\3\2\2\2\u0482\u00e3\3\2"+
+		"\2\2\u0483\u0481\3\2\2\2\u0484\u0485\7i\2\2\u0485\u0486\5\62\32\2\u0486"+
+		"\u00e5\3\2\2\2\u0487\u0488\7i\2\2\u0488\u0489\5\62\32\2\u0489\u048a\7"+
+		";\2\2\u048a\u048b\5\u00dep\2\u048b\u048c\7<\2\2\u048c\u00e7\3\2\2\2\u048d"+
+		"\u048f\7=\2\2\u048e\u0490\5\u00eav\2\u048f\u048e\3\2\2\2\u048f\u0490\3"+
+		"\2\2\2\u0490\u0492\3\2\2\2\u0491\u0493\7B\2\2\u0492\u0491\3\2\2\2\u0492"+
+		"\u0493\3\2\2\2\u0493\u0494\3\2\2\2\u0494\u0495\7>\2\2\u0495\u00e9\3\2"+
+		"\2\2\u0496\u049b\5f\64\2\u0497\u0498\7B\2\2\u0498\u049a\5f\64\2\u0499"+
+		"\u0497\3\2\2\2\u049a\u049d\3\2\2\2\u049b\u0499\3\2\2\2\u049b\u049c\3\2"+
+		"\2\2\u049c\u00eb\3\2\2\2\u049d\u049b\3\2\2\2\u049e\u04a0\7=\2\2\u049f"+
+		"\u04a1\5\u00eex\2\u04a0\u049f\3\2\2\2\u04a0\u04a1\3\2\2\2\u04a1\u04a2"+
+		"\3\2\2\2\u04a2\u04a3\7>\2\2\u04a3\u00ed\3\2\2\2\u04a4\u04a6\13\2\2\2\u04a5"+
+		"\u04a4\3\2\2\2\u04a6\u04a7\3\2\2\2\u04a7\u04a8\3\2\2\2\u04a7\u04a5\3\2"+
+		"\2\2\u04a8\u00ef\3\2\2\2\u0094\u00f3\u00fa\u00fe\u0102\u010b\u010f\u0113"+
+		"\u0115\u011b\u0120\u0127\u012c\u012e\u0134\u0139\u013e\u0143\u014e\u015c"+
+		"\u0161\u0169\u0170\u0176\u017b\u0186\u0189\u0197\u019c\u01a1\u01a6\u01ac"+
+		"\u01b3\u01bd\u01c5\u01cf\u01d3\u01d8\u01de\u01e6\u01ef\u01fa\u0217\u021b"+
+		"\u0220\u0226\u0229\u022c\u0238\u0243\u0251\u0258\u0261\u0268\u026d\u0273"+
+		"\u0277\u027b\u027f\u0284\u0288\u028c\u028e\u0295\u029a\u029e\u02af\u02b4"+
+		"\u02c4\u02c9\u02cf\u02d5\u02d7\u02db\u02e0\u02e4\u02eb\u02f2\u02fa\u02fd"+
+		"\u0302\u030a\u030f\u0316\u031d\u0322\u0328\u0334\u0339\u033d\u0347\u034c"+
+		"\u0354\u0357\u035c\u0364\u0367\u036c\u0371\u0376\u037b\u0382\u0387\u038f"+
+		"\u0394\u0399\u039e\u03a4\u03aa\u03ad\u03b0\u03b9\u03bf\u03c5\u03c8\u03cb"+
+		"\u03d3\u03db\u03e1\u03e6\u03eb\u03ef\u03f4\u03fa\u03fd\u0408\u0411\u041b"+
+		"\u0420\u0427\u042f\u0434\u0440\u0445\u0451\u0458\u045e\u0467\u0471\u0475"+
+		"\u0478\u0481\u048f\u0492\u049b\u04a0\u04a7";
+	public static final ATN _ATN =
+		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
+	static {
+		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
+		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
+			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
+		}
+	}
+}
\ No newline at end of file

From abafed9d378083e3d812fb4b05cecb1c2a078033 Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Sat, 28 May 2016 23:38:42 +0600
Subject: [PATCH 02/22] UPCSEC-0000 Implemented recognition for nested classes
 hierarchy and various method signatures

---
 .../ru/ftc/upc/testing/dropper/Cutpoint.java  |    2 +-
 .../testing/dropper/lang/DropletChecker.java  |   29 -
 .../dropper/lang/DropperTreeListener.java     |  124 +-
 .../upc/testing/dropper/lang/DroppingJava.g4  |   84 +-
 .../upc/testing/dropper/lang/TargetsMap.java  |   39 +
 .../lang/gen/DroppingJavaBaseListener.java    |   92 +-
 .../lang/gen/DroppingJavaBaseVisitor.java     |  840 ++++
 .../lang/gen/DroppingJavaListener.java        |   90 +-
 .../dropper/lang/gen/DroppingJavaParser.java  | 3722 +++++++++--------
 .../dropper/lang/gen/DroppingJavaVisitor.java |  725 ++++
 .../upc/testing/dropper/model/Argument.java   |   30 +
 .../testing/dropper/model/TargetMethod.java   |   86 +
 .../dropper/lang/DropperTreeListenerTest.java |   76 +
 13 files changed, 4054 insertions(+), 1885 deletions(-)
 delete mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/DropletChecker.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/TargetsMap.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseVisitor.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaVisitor.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/model/Argument.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
 create mode 100644 src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java

diff --git a/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java b/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java
index a1e2002..edf3deb 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java
@@ -4,7 +4,7 @@
  * Created by Plizga on 29.04.2016 11:59
  */
 @SuppressWarnings("unused")       // все элементы перечисления на самом деле используются через метод Enum#valueOf()
-enum Cutpoint {
+public enum Cutpoint {
   BEFORE(BeforeMethodPatcher.class),
   INSTEAD(InsteadMethodPatcher.class),
   AFTER(AfterMethodPatcher.class);
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletChecker.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletChecker.java
deleted file mode 100644
index f6118a7..0000000
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletChecker.java
+++ /dev/null
@@ -1,29 +0,0 @@
-package ru.ftc.upc.testing.dropper.lang;
-
-import org.antlr.v4.runtime.ANTLRFileStream;
-import org.antlr.v4.runtime.CommonTokenStream;
-import org.antlr.v4.runtime.TokenStream;
-import org.antlr.v4.runtime.tree.ParseTree;
-import org.antlr.v4.runtime.tree.ParseTreeWalker;
-import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaLexer;
-import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
-
-import java.io.IOException;
-
-/**
- * @author Toparvion
- */
-public class DropletChecker {
-
-  public static void main(String[] args) throws IOException {
-    ANTLRFileStream fileStream = new ANTLRFileStream("C:\\lang\\dropper\\src\\main\\java\\ru\\ftc\\upc\\testing\\dropper\\PatchingTransformer.java");
-    DroppingJavaLexer lexer = new DroppingJavaLexer(fileStream);
-    TokenStream tokenStream = new CommonTokenStream(lexer);
-    DroppingJavaParser parser = new DroppingJavaParser(tokenStream);
-    ParseTree tree = parser.compilationUnit();
-
-    DropperTreeListener listener = new DropperTreeListener();
-    ParseTreeWalker walker = new ParseTreeWalker();
-    walker.walk(listener, tree);
-  }
-}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java
index 388de65..e629de2 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java
@@ -1,35 +1,135 @@
 package ru.ftc.upc.testing.dropper.lang;
 
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.RuleContext;
+import org.antlr.v4.runtime.tree.RuleNode;
+import org.antlr.v4.runtime.tree.TerminalNode;
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaBaseListener;
+import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaBaseVisitor;
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
+import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaVisitor;
+import ru.ftc.upc.testing.dropper.model.Argument;
+import ru.ftc.upc.testing.dropper.model.TargetMethod;
+
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.LinkedList;
 
 /**
  * @author Toparvion
  */
 public class DropperTreeListener extends DroppingJavaBaseListener {
 
+  private Deque<String> classStack = new LinkedList<String>();
+  private TargetsMap targetsMap = new TargetsMap();
+
   @Override
-  public void enterVariableDeclaratorId(DroppingJavaParser.VariableDeclaratorIdContext ctx) {
-    System.out.println("Method formal parameter name found: " + ctx.getText());
+  public void enterNormalClassDeclaration(DroppingJavaParser.NormalClassDeclarationContext ctx) {
+    classStack.push(ctx.Identifier().getText());
   }
 
   @Override
-  public void enterClassName(DroppingJavaParser.ClassNameContext ctx) {
-    System.out.println("Class name found: " + ctx.Identifier().getText());
+  public void exitNormalClassDeclaration(DroppingJavaParser.NormalClassDeclarationContext ctx) {
+    classStack.pop();
   }
 
   @Override
-  public void enterSingleTypeImportDeclaration(DroppingJavaParser.SingleTypeImportDeclarationContext ctx) {
-    System.out.printf("Single import found: %s\n", ctx.typeName().getText());
+  public void enterMethodHeader(DroppingJavaParser.MethodHeaderContext ctx) {
+    // first of all let's save this method itself
+    String key = composeCurrentKey();
+    DroppingJavaParser.MethodDeclaratorContext declarator = ctx.methodDeclarator();
+    TargetMethod method = new TargetMethod(declarator.Identifier().getText());
+    targetsMap.appendMethod(key, method);
+
+    // store method's result type name
+    DroppingJavaParser.ResultContext result = ctx.result();
+    String resultType = getPureTypeName(result);
+    method.setResultType(resultType);
+
+    // it's time to store method parameters, if any
+    DroppingJavaParser.FormalParameterListContext anyParams = declarator.formalParameterList();
+    if (anyParams == null) return;
+    String paramType;
+    String paramName;
+    // first we check for any normal formal params
+    DroppingJavaParser.FormalParametersContext formalParams = anyParams.formalParameters();
+    if (formalParams != null) {
+      for (DroppingJavaParser.FormalParameterContext param : formalParams.formalParameter()) {
+        paramType = getPureTypeName(param.unannType());
+        paramName = param.variableDeclaratorId().Identifier().getText();
+        method.getFormalParams().add(new Argument(paramType, paramName));
+      }
+    }
+    // now we check for the last formal param which can be ellipsis one
+    DroppingJavaParser.LastFormalParameterContext lastFormalParam = anyParams.lastFormalParameter();
+    if (lastFormalParam != null) {
+      DroppingJavaParser.FormalParameterContext formalParam = lastFormalParam.formalParameter();
+      if (formalParam != null) {
+        paramType = getPureTypeName(formalParam.unannType());
+        paramName = formalParam.variableDeclaratorId().Identifier().getText();
+      } else {
+        paramType = getPureTypeName(lastFormalParam.unannType());
+        paramName = lastFormalParam.variableDeclaratorId().Identifier().getText();
+      }
+      method.getFormalParams().add(new Argument(paramType, paramName));
+    }
   }
 
-  @Override
-  public void enterMethodName(DroppingJavaParser.MethodNameContext ctx) {
-    System.out.printf("Method name found: %s\n", ctx.Identifier().getText());
+  /**
+   * @return a key for target class map (basing on current state of the stack)
+   */
+  private String composeCurrentKey() {
+    StringBuilder sb = new StringBuilder();
+    boolean first = true;
+    for (Iterator<String> iterator = classStack.descendingIterator(); iterator.hasNext(); ) {
+      String className = iterator.next();
+      if (!first) {
+        sb.append(".");
+      } else {
+        first = false;
+      }
+      sb.append(className);
+    }
+
+    return sb.toString();
   }
 
-  @Override
-  public void enterConstructorName(DroppingJavaParser.ConstructorNameContext ctx) {
-    System.out.printf("Constructor name found: %s\n", ctx.Identifier().getText());
+  public TargetsMap getTargetsMap() {
+    return targetsMap;
+  }
+
+  private String getSpacedText(ParserRuleContext ctx) {
+    int childCount = ctx.getChildCount();
+    if (childCount == 0) {
+      return "";
+    }
+
+    StringBuilder sb = new StringBuilder(ctx.getChild(0).getText());
+    for (int i=1; i<childCount; i++) {
+      sb.append(" ").append(ctx.getChild(i));
+    }
+
+    return sb.toString();
+  }
+
+  private String getPureTypeName(RuleContext typeCtx) {
+    DroppingJavaVisitor<String> visitor = new FirstIdTreeVisitor();
+    return visitor.visit(typeCtx);
+  }
+
+  /**
+   * Simple visitor that reaches the very first terminal node (starting from the one specified in
+   * {@link #visitTerminal} method) and returns the node's text value.
+   */
+  private static class FirstIdTreeVisitor extends DroppingJavaBaseVisitor<String> {
+    @Override
+    public String visitTerminal(TerminalNode node) {
+      return node.getText();
+    }
+
+    @Override
+    protected boolean shouldVisitNextChild(RuleNode node, String currentResult) {
+      return (currentResult == null);
+    }
   }
 }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4 b/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4
index 92d8a8b..74615d9 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4
@@ -29,34 +29,11 @@
  */
 
 /**
- * A Java 8 grammar for ANTLR 4 derived from the Java Language Specification
+ * A modified (and simplified) Java 8 grammar for ANTLR 4 derived from the Java Language Specification
  * chapter 19.
- *
- * NOTE: This grammar results in a generated parser that is much slower
- *       than the Java 7 grammar in the grammars-v4/java directory. This
- *     one is, however, extremely close to the spec.
- *
- * You can test with
- *
- *  $ antlr4 Java8.g4
- *  $ javac *.java
- *  $ grun Java8 compilationUnit *.java
- *
- * Or,
-~/antlr/code/grammars-v4/java8 $ java Test .
-/Users/parrt/antlr/code/grammars-v4/java8/./Java8BaseListener.java
-/Users/parrt/antlr/code/grammars-v4/java8/./Java8Lexer.java
-/Users/parrt/antlr/code/grammars-v4/java8/./Java8Listener.java
-/Users/parrt/antlr/code/grammars-v4/java8/./Java8Parser.java
-/Users/parrt/antlr/code/grammars-v4/java8/./Test.java
-Total lexer+parser time 30844ms.
  */
 grammar DroppingJava;
 
-/*
- * Productions from §3 (Lexical Structure)
- */
-
 /*
  * Productions from §4 (Types, Values, and Variables)
  */
@@ -191,16 +168,6 @@ packageOrTypeName
 	|	packageOrTypeName '.' Identifier
 	;
 
-expressionName
-	:	Identifier
-	|	ambiguousName '.' Identifier
-	;
-
-ambiguousName
-	:	Identifier
-	|	ambiguousName '.' Identifier
-	;
-
 /*
  * Productions from §7 (Packages)
  */
@@ -256,7 +223,7 @@ classDeclaration
 	;
 
 normalClassDeclaration
-	:	classModifier* 'class' Identifier typeParameters? superclass? superinterfaces? classBody  # ClassName
+	:	classModifier* 'class' Identifier typeParameters? superclass? superinterfaces? classBody  // # ClassName
 	;
 
 classModifier
@@ -310,7 +277,26 @@ classMemberDeclaration
 	;
 
 fieldDeclaration
-	:	.+? ';'
+	:	fieldModifier* unannType variableDeclaratorList ';'
+	;
+
+fieldModifier
+	:	annotation
+	|	'public'
+	|	'protected'
+	|	'private'
+	|	'static'
+	|	'final'
+	|	'transient'
+	|	'volatile'
+	;
+
+variableDeclaratorList
+	:	variableDeclarator (',' variableDeclarator)*
+	;
+
+variableDeclarator
+	:	variableDeclaratorId ('=' variableInitializer)?
 	;
 
 variableDeclaratorId
@@ -401,7 +387,7 @@ result
 	;
 
 methodDeclarator
-	:	Identifier '(' formalParameterList? ')' dims?               # MethodName
+	:	Identifier '(' formalParameterList? ')' dims?
 	;
 
 formalParameterList
@@ -478,14 +464,7 @@ simpleTypeName
 	;
 
 constructorBody
-	:	'{' explicitConstructorInvocation? blockStatements? '}'
-	;
-
-explicitConstructorInvocation
-	:	typeArguments? 'this' '(' argumentList? ')' ';'
-	|	typeArguments? 'super' '(' argumentList? ')' ';'
-	|	expressionName '.' typeArguments? 'super' '(' argumentList? ')' ';'
-	|	primary '.' typeArguments? 'super' '(' argumentList? ')' ';'
+	:	'{' blockStatements '}'     // '{' explicitConstructorInvocation? blockStatements? '}'
 	;
 
 enumDeclaration
@@ -528,17 +507,6 @@ conditionalExpression
         :       .+?
         ;
 
-primary
-	    :       .+?
-        ;
-/* primary
-	:	(	primaryNoNewArray_lfno_primary
-		|	arrayCreationExpression
-		)
-		(	primaryNoNewArray_lf_primary
-		)*
-	; */
-
 /*
  * Productions from §9 (Interfaces)
  */
@@ -667,11 +635,11 @@ variableInitializerList
  */
 
 block
-	:	'{' blockStatements? '}'
+	:	'{' blockStatements '}'
 	;
 
 blockStatements
-	:	.+?
+	:	.*?
 	;
 
 /*
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/TargetsMap.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/TargetsMap.java
new file mode 100644
index 0000000..cfa562d
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/TargetsMap.java
@@ -0,0 +1,39 @@
+package ru.ftc.upc.testing.dropper.lang;
+
+import ru.ftc.upc.testing.dropper.model.TargetMethod;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+/**
+ * @author Toparvion
+ */
+public class TargetsMap extends TreeMap<String, List<TargetMethod>> {
+
+  public void appendMethod(String key, TargetMethod method) {
+    List<TargetMethod> methods = this.get(key);
+    if (methods == null) {
+      methods = new LinkedList<TargetMethod>();
+      methods.add(method);
+      this.put(key, methods);
+
+    } else {
+      methods.add(method);
+    }
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder();
+    for (Map.Entry<String, List<TargetMethod>> entry : this.entrySet()) {
+      sb.append(entry.getKey()).append(" -> {\n");
+      for (TargetMethod method : entry.getValue()) {
+        sb.append("\t").append(method).append("\n");
+      }
+      sb.append("}\n");
+    }
+    return sb.toString();
+  }
+}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java
index 8b45b8d..bc16085 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java
@@ -323,30 +323,6 @@ public class DroppingJavaBaseListener implements DroppingJavaListener {
 	 * <p>The default implementation does nothing.</p>
 	 */
 	@Override public void exitPackageOrTypeName(DroppingJavaParser.PackageOrTypeNameContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterExpressionName(DroppingJavaParser.ExpressionNameContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitExpressionName(DroppingJavaParser.ExpressionNameContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterAmbiguousName(DroppingJavaParser.AmbiguousNameContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitAmbiguousName(DroppingJavaParser.AmbiguousNameContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *
@@ -472,13 +448,13 @@ public class DroppingJavaBaseListener implements DroppingJavaListener {
 	 *
 	 * <p>The default implementation does nothing.</p>
 	 */
-	@Override public void enterClassName(DroppingJavaParser.ClassNameContext ctx) { }
+	@Override public void enterNormalClassDeclaration(DroppingJavaParser.NormalClassDeclarationContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *
 	 * <p>The default implementation does nothing.</p>
 	 */
-	@Override public void exitClassName(DroppingJavaParser.ClassNameContext ctx) { }
+	@Override public void exitNormalClassDeclaration(DroppingJavaParser.NormalClassDeclarationContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *
@@ -599,6 +575,42 @@ public class DroppingJavaBaseListener implements DroppingJavaListener {
 	 * <p>The default implementation does nothing.</p>
 	 */
 	@Override public void exitFieldDeclaration(DroppingJavaParser.FieldDeclarationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterFieldModifier(DroppingJavaParser.FieldModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitFieldModifier(DroppingJavaParser.FieldModifierContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterVariableDeclaratorList(DroppingJavaParser.VariableDeclaratorListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitVariableDeclaratorList(DroppingJavaParser.VariableDeclaratorListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterVariableDeclarator(DroppingJavaParser.VariableDeclaratorContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitVariableDeclarator(DroppingJavaParser.VariableDeclaratorContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *
@@ -796,13 +808,13 @@ public class DroppingJavaBaseListener implements DroppingJavaListener {
 	 *
 	 * <p>The default implementation does nothing.</p>
 	 */
-	@Override public void enterMethodName(DroppingJavaParser.MethodNameContext ctx) { }
+	@Override public void enterMethodDeclarator(DroppingJavaParser.MethodDeclaratorContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *
 	 * <p>The default implementation does nothing.</p>
 	 */
-	@Override public void exitMethodName(DroppingJavaParser.MethodNameContext ctx) { }
+	@Override public void exitMethodDeclarator(DroppingJavaParser.MethodDeclaratorContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *
@@ -1007,18 +1019,6 @@ public class DroppingJavaBaseListener implements DroppingJavaListener {
 	 * <p>The default implementation does nothing.</p>
 	 */
 	@Override public void exitConstructorBody(DroppingJavaParser.ConstructorBodyContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterExplicitConstructorInvocation(DroppingJavaParser.ExplicitConstructorInvocationContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitExplicitConstructorInvocation(DroppingJavaParser.ExplicitConstructorInvocationContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *
@@ -1127,18 +1127,6 @@ public class DroppingJavaBaseListener implements DroppingJavaListener {
 	 * <p>The default implementation does nothing.</p>
 	 */
 	@Override public void exitConditionalExpression(DroppingJavaParser.ConditionalExpressionContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterPrimary(DroppingJavaParser.PrimaryContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitPrimary(DroppingJavaParser.PrimaryContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseVisitor.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseVisitor.java
new file mode 100644
index 0000000..a58033d
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseVisitor.java
@@ -0,0 +1,840 @@
+// Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\DroppingJava.g4 by ANTLR 4.5.1
+package ru.ftc.upc.testing.dropper.lang.gen;
+import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
+
+/**
+ * This class provides an empty implementation of {@link DroppingJavaVisitor},
+ * which can be extended to create a visitor which only needs to handle a subset
+ * of the available methods.
+ *
+ * @param <T> The return type of the visit operation. Use {@link Void} for
+ * operations with no return type.
+ */
+public class DroppingJavaBaseVisitor<T> extends AbstractParseTreeVisitor<T> implements DroppingJavaVisitor<T> {
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitPrimitiveType(DroppingJavaParser.PrimitiveTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitNumericType(DroppingJavaParser.NumericTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitIntegralType(DroppingJavaParser.IntegralTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitFloatingPointType(DroppingJavaParser.FloatingPointTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitReferenceType(DroppingJavaParser.ReferenceTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitClassOrInterfaceType(DroppingJavaParser.ClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitClassType(DroppingJavaParser.ClassTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitClassType_lf_classOrInterfaceType(DroppingJavaParser.ClassType_lf_classOrInterfaceTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitClassType_lfno_classOrInterfaceType(DroppingJavaParser.ClassType_lfno_classOrInterfaceTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitInterfaceType(DroppingJavaParser.InterfaceTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitInterfaceType_lf_classOrInterfaceType(DroppingJavaParser.InterfaceType_lf_classOrInterfaceTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitInterfaceType_lfno_classOrInterfaceType(DroppingJavaParser.InterfaceType_lfno_classOrInterfaceTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitTypeVariable(DroppingJavaParser.TypeVariableContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitArrayType(DroppingJavaParser.ArrayTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitDims(DroppingJavaParser.DimsContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitTypeParameter(DroppingJavaParser.TypeParameterContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitTypeParameterModifier(DroppingJavaParser.TypeParameterModifierContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitTypeBound(DroppingJavaParser.TypeBoundContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitAdditionalBound(DroppingJavaParser.AdditionalBoundContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitTypeArguments(DroppingJavaParser.TypeArgumentsContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitTypeArgumentList(DroppingJavaParser.TypeArgumentListContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitTypeArgument(DroppingJavaParser.TypeArgumentContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitWildcard(DroppingJavaParser.WildcardContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitWildcardBounds(DroppingJavaParser.WildcardBoundsContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitTypeName(DroppingJavaParser.TypeNameContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitPackageOrTypeName(DroppingJavaParser.PackageOrTypeNameContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitCompilationUnit(DroppingJavaParser.CompilationUnitContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitPackageDeclaration(DroppingJavaParser.PackageDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitPackageModifier(DroppingJavaParser.PackageModifierContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitImportDeclaration(DroppingJavaParser.ImportDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitSingleTypeImportDeclaration(DroppingJavaParser.SingleTypeImportDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitTypeImportOnDemandDeclaration(DroppingJavaParser.TypeImportOnDemandDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitSingleStaticImportDeclaration(DroppingJavaParser.SingleStaticImportDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitStaticImportOnDemandDeclaration(DroppingJavaParser.StaticImportOnDemandDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitTypeDeclaration(DroppingJavaParser.TypeDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitClassDeclaration(DroppingJavaParser.ClassDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitNormalClassDeclaration(DroppingJavaParser.NormalClassDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitClassModifier(DroppingJavaParser.ClassModifierContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitTypeParameters(DroppingJavaParser.TypeParametersContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitTypeParameterList(DroppingJavaParser.TypeParameterListContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitSuperclass(DroppingJavaParser.SuperclassContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitSuperinterfaces(DroppingJavaParser.SuperinterfacesContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitInterfaceTypeList(DroppingJavaParser.InterfaceTypeListContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitClassBody(DroppingJavaParser.ClassBodyContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitClassBodyDeclaration(DroppingJavaParser.ClassBodyDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitClassMemberDeclaration(DroppingJavaParser.ClassMemberDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitFieldDeclaration(DroppingJavaParser.FieldDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitFieldModifier(DroppingJavaParser.FieldModifierContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitVariableDeclaratorList(DroppingJavaParser.VariableDeclaratorListContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitVariableDeclarator(DroppingJavaParser.VariableDeclaratorContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitVariableDeclaratorId(DroppingJavaParser.VariableDeclaratorIdContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitVariableInitializer(DroppingJavaParser.VariableInitializerContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitUnannType(DroppingJavaParser.UnannTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitUnannPrimitiveType(DroppingJavaParser.UnannPrimitiveTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitUnannReferenceType(DroppingJavaParser.UnannReferenceTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitUnannClassOrInterfaceType(DroppingJavaParser.UnannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitUnannClassType_lf_unannClassOrInterfaceType(DroppingJavaParser.UnannClassType_lf_unannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitUnannClassType_lfno_unannClassOrInterfaceType(DroppingJavaParser.UnannClassType_lfno_unannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitUnannInterfaceType_lf_unannClassOrInterfaceType(DroppingJavaParser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitUnannInterfaceType_lfno_unannClassOrInterfaceType(DroppingJavaParser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitUnannTypeVariable(DroppingJavaParser.UnannTypeVariableContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitUnannArrayType(DroppingJavaParser.UnannArrayTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitMethodDeclaration(DroppingJavaParser.MethodDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitMethodModifier(DroppingJavaParser.MethodModifierContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitMethodHeader(DroppingJavaParser.MethodHeaderContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitResult(DroppingJavaParser.ResultContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitMethodDeclarator(DroppingJavaParser.MethodDeclaratorContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitFormalParameterList(DroppingJavaParser.FormalParameterListContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitFormalParameters(DroppingJavaParser.FormalParametersContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitFormalParameter(DroppingJavaParser.FormalParameterContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitVariableModifier(DroppingJavaParser.VariableModifierContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitLastFormalParameter(DroppingJavaParser.LastFormalParameterContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitReceiverParameter(DroppingJavaParser.ReceiverParameterContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitThrows_(DroppingJavaParser.Throws_Context ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitExceptionTypeList(DroppingJavaParser.ExceptionTypeListContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitExceptionType(DroppingJavaParser.ExceptionTypeContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitMethodBody(DroppingJavaParser.MethodBodyContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitInstanceInitializer(DroppingJavaParser.InstanceInitializerContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitStaticInitializer(DroppingJavaParser.StaticInitializerContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitConstructorDeclaration(DroppingJavaParser.ConstructorDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitConstructorModifier(DroppingJavaParser.ConstructorModifierContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitConstructorDeclarator(DroppingJavaParser.ConstructorDeclaratorContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitConstructorName(DroppingJavaParser.ConstructorNameContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitConstructorBody(DroppingJavaParser.ConstructorBodyContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitEnumName(DroppingJavaParser.EnumNameContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitEnumBody(DroppingJavaParser.EnumBodyContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitEnumConstantList(DroppingJavaParser.EnumConstantListContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitEnumConstant(DroppingJavaParser.EnumConstantContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitEnumConstantModifier(DroppingJavaParser.EnumConstantModifierContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitEnumBodyDeclarations(DroppingJavaParser.EnumBodyDeclarationsContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitArgumentList(DroppingJavaParser.ArgumentListContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitExpression(DroppingJavaParser.ExpressionContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitConditionalExpression(DroppingJavaParser.ConditionalExpressionContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitInterfaceDeclaration(DroppingJavaParser.InterfaceDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitIfaceName(DroppingJavaParser.IfaceNameContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitInterfaceModifier(DroppingJavaParser.InterfaceModifierContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitExtendsInterfaces(DroppingJavaParser.ExtendsInterfacesContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitInterfaceBody(DroppingJavaParser.InterfaceBodyContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitInterfaceMemberDeclaration(DroppingJavaParser.InterfaceMemberDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitConstantDeclaration(DroppingJavaParser.ConstantDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitConstantModifier(DroppingJavaParser.ConstantModifierContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitInterfaceMethodDeclaration(DroppingJavaParser.InterfaceMethodDeclarationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitInterfaceMethodModifier(DroppingJavaParser.InterfaceMethodModifierContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitAnnoName(DroppingJavaParser.AnnoNameContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitAnnotationTypeBody(DroppingJavaParser.AnnotationTypeBodyContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitAnnotation(DroppingJavaParser.AnnotationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitNormalAnnotation(DroppingJavaParser.NormalAnnotationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitElementValuePairList(DroppingJavaParser.ElementValuePairListContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitElementValuePair(DroppingJavaParser.ElementValuePairContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitElementValue(DroppingJavaParser.ElementValueContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitElementValueArrayInitializer(DroppingJavaParser.ElementValueArrayInitializerContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitElementValueList(DroppingJavaParser.ElementValueListContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitMarkerAnnotation(DroppingJavaParser.MarkerAnnotationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitSingleElementAnnotation(DroppingJavaParser.SingleElementAnnotationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitArrayInitializer(DroppingJavaParser.ArrayInitializerContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitVariableInitializerList(DroppingJavaParser.VariableInitializerListContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitBlock(DroppingJavaParser.BlockContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitBlockStatements(DroppingJavaParser.BlockStatementsContext ctx) { return visitChildren(ctx); }
+}
\ No newline at end of file
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java
index 409502c..f2d41a3 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java
@@ -267,26 +267,6 @@ public interface DroppingJavaListener extends ParseTreeListener {
 	 * @param ctx the parse tree
 	 */
 	void exitPackageOrTypeName(DroppingJavaParser.PackageOrTypeNameContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link DroppingJavaParser#expressionName}.
-	 * @param ctx the parse tree
-	 */
-	void enterExpressionName(DroppingJavaParser.ExpressionNameContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link DroppingJavaParser#expressionName}.
-	 * @param ctx the parse tree
-	 */
-	void exitExpressionName(DroppingJavaParser.ExpressionNameContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link DroppingJavaParser#ambiguousName}.
-	 * @param ctx the parse tree
-	 */
-	void enterAmbiguousName(DroppingJavaParser.AmbiguousNameContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link DroppingJavaParser#ambiguousName}.
-	 * @param ctx the parse tree
-	 */
-	void exitAmbiguousName(DroppingJavaParser.AmbiguousNameContext ctx);
 	/**
 	 * Enter a parse tree produced by {@link DroppingJavaParser#compilationUnit}.
 	 * @param ctx the parse tree
@@ -388,17 +368,15 @@ public interface DroppingJavaListener extends ParseTreeListener {
 	 */
 	void exitClassDeclaration(DroppingJavaParser.ClassDeclarationContext ctx);
 	/**
-	 * Enter a parse tree produced by the {@code ClassName}
-	 * labeled alternative in {@link DroppingJavaParser#normalClassDeclaration}.
+	 * Enter a parse tree produced by {@link DroppingJavaParser#normalClassDeclaration}.
 	 * @param ctx the parse tree
 	 */
-	void enterClassName(DroppingJavaParser.ClassNameContext ctx);
+	void enterNormalClassDeclaration(DroppingJavaParser.NormalClassDeclarationContext ctx);
 	/**
-	 * Exit a parse tree produced by the {@code ClassName}
-	 * labeled alternative in {@link DroppingJavaParser#normalClassDeclaration}.
+	 * Exit a parse tree produced by {@link DroppingJavaParser#normalClassDeclaration}.
 	 * @param ctx the parse tree
 	 */
-	void exitClassName(DroppingJavaParser.ClassNameContext ctx);
+	void exitNormalClassDeclaration(DroppingJavaParser.NormalClassDeclarationContext ctx);
 	/**
 	 * Enter a parse tree produced by {@link DroppingJavaParser#classModifier}.
 	 * @param ctx the parse tree
@@ -499,6 +477,36 @@ public interface DroppingJavaListener extends ParseTreeListener {
 	 * @param ctx the parse tree
 	 */
 	void exitFieldDeclaration(DroppingJavaParser.FieldDeclarationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#fieldModifier}.
+	 * @param ctx the parse tree
+	 */
+	void enterFieldModifier(DroppingJavaParser.FieldModifierContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#fieldModifier}.
+	 * @param ctx the parse tree
+	 */
+	void exitFieldModifier(DroppingJavaParser.FieldModifierContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#variableDeclaratorList}.
+	 * @param ctx the parse tree
+	 */
+	void enterVariableDeclaratorList(DroppingJavaParser.VariableDeclaratorListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#variableDeclaratorList}.
+	 * @param ctx the parse tree
+	 */
+	void exitVariableDeclaratorList(DroppingJavaParser.VariableDeclaratorListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link DroppingJavaParser#variableDeclarator}.
+	 * @param ctx the parse tree
+	 */
+	void enterVariableDeclarator(DroppingJavaParser.VariableDeclaratorContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link DroppingJavaParser#variableDeclarator}.
+	 * @param ctx the parse tree
+	 */
+	void exitVariableDeclarator(DroppingJavaParser.VariableDeclaratorContext ctx);
 	/**
 	 * Enter a parse tree produced by {@link DroppingJavaParser#variableDeclaratorId}.
 	 * @param ctx the parse tree
@@ -660,17 +668,15 @@ public interface DroppingJavaListener extends ParseTreeListener {
 	 */
 	void exitResult(DroppingJavaParser.ResultContext ctx);
 	/**
-	 * Enter a parse tree produced by the {@code MethodName}
-	 * labeled alternative in {@link DroppingJavaParser#methodDeclarator}.
+	 * Enter a parse tree produced by {@link DroppingJavaParser#methodDeclarator}.
 	 * @param ctx the parse tree
 	 */
-	void enterMethodName(DroppingJavaParser.MethodNameContext ctx);
+	void enterMethodDeclarator(DroppingJavaParser.MethodDeclaratorContext ctx);
 	/**
-	 * Exit a parse tree produced by the {@code MethodName}
-	 * labeled alternative in {@link DroppingJavaParser#methodDeclarator}.
+	 * Exit a parse tree produced by {@link DroppingJavaParser#methodDeclarator}.
 	 * @param ctx the parse tree
 	 */
-	void exitMethodName(DroppingJavaParser.MethodNameContext ctx);
+	void exitMethodDeclarator(DroppingJavaParser.MethodDeclaratorContext ctx);
 	/**
 	 * Enter a parse tree produced by {@link DroppingJavaParser#formalParameterList}.
 	 * @param ctx the parse tree
@@ -843,16 +849,6 @@ public interface DroppingJavaListener extends ParseTreeListener {
 	 * @param ctx the parse tree
 	 */
 	void exitConstructorBody(DroppingJavaParser.ConstructorBodyContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link DroppingJavaParser#explicitConstructorInvocation}.
-	 * @param ctx the parse tree
-	 */
-	void enterExplicitConstructorInvocation(DroppingJavaParser.ExplicitConstructorInvocationContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link DroppingJavaParser#explicitConstructorInvocation}.
-	 * @param ctx the parse tree
-	 */
-	void exitExplicitConstructorInvocation(DroppingJavaParser.ExplicitConstructorInvocationContext ctx);
 	/**
 	 * Enter a parse tree produced by the {@code EnumName}
 	 * labeled alternative in {@link DroppingJavaParser#enumDeclaration}.
@@ -945,16 +941,6 @@ public interface DroppingJavaListener extends ParseTreeListener {
 	 * @param ctx the parse tree
 	 */
 	void exitConditionalExpression(DroppingJavaParser.ConditionalExpressionContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link DroppingJavaParser#primary}.
-	 * @param ctx the parse tree
-	 */
-	void enterPrimary(DroppingJavaParser.PrimaryContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link DroppingJavaParser#primary}.
-	 * @param ctx the parse tree
-	 */
-	void exitPrimary(DroppingJavaParser.PrimaryContext ctx);
 	/**
 	 * Enter a parse tree produced by {@link DroppingJavaParser#interfaceDeclaration}.
 	 * @param ctx the parse tree
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java
index 9d758e6..717aa2c 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java
@@ -1,6 +1,5 @@
 // Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\DroppingJava.g4 by ANTLR 4.5.1
 package ru.ftc.upc.testing.dropper.lang.gen;
-
 import org.antlr.v4.runtime.*;
 import org.antlr.v4.runtime.atn.ATN;
 import org.antlr.v4.runtime.atn.ATNDeserializer;
@@ -8,6 +7,7 @@
 import org.antlr.v4.runtime.atn.PredictionContextCache;
 import org.antlr.v4.runtime.dfa.DFA;
 import org.antlr.v4.runtime.tree.ParseTreeListener;
+import org.antlr.v4.runtime.tree.ParseTreeVisitor;
 import org.antlr.v4.runtime.tree.TerminalNode;
 
 import java.util.List;
@@ -47,39 +47,38 @@ public class DroppingJavaParser extends Parser {
 		RULE_typeBound = 17, RULE_additionalBound = 18, RULE_typeArguments = 19, 
 		RULE_typeArgumentList = 20, RULE_typeArgument = 21, RULE_wildcard = 22, 
 		RULE_wildcardBounds = 23, RULE_typeName = 24, RULE_packageOrTypeName = 25, 
-		RULE_expressionName = 26, RULE_ambiguousName = 27, RULE_compilationUnit = 28, 
-		RULE_packageDeclaration = 29, RULE_packageModifier = 30, RULE_importDeclaration = 31, 
-		RULE_singleTypeImportDeclaration = 32, RULE_typeImportOnDemandDeclaration = 33, 
-		RULE_singleStaticImportDeclaration = 34, RULE_staticImportOnDemandDeclaration = 35, 
-		RULE_typeDeclaration = 36, RULE_classDeclaration = 37, RULE_normalClassDeclaration = 38, 
-		RULE_classModifier = 39, RULE_typeParameters = 40, RULE_typeParameterList = 41, 
-		RULE_superclass = 42, RULE_superinterfaces = 43, RULE_interfaceTypeList = 44, 
-		RULE_classBody = 45, RULE_classBodyDeclaration = 46, RULE_classMemberDeclaration = 47, 
-		RULE_fieldDeclaration = 48, RULE_variableDeclaratorId = 49, RULE_variableInitializer = 50, 
-		RULE_unannType = 51, RULE_unannPrimitiveType = 52, RULE_unannReferenceType = 53, 
-		RULE_unannClassOrInterfaceType = 54, RULE_unannClassType_lf_unannClassOrInterfaceType = 55, 
-		RULE_unannClassType_lfno_unannClassOrInterfaceType = 56, RULE_unannInterfaceType_lf_unannClassOrInterfaceType = 57, 
-		RULE_unannInterfaceType_lfno_unannClassOrInterfaceType = 58, RULE_unannTypeVariable = 59, 
-		RULE_unannArrayType = 60, RULE_methodDeclaration = 61, RULE_methodModifier = 62, 
-		RULE_methodHeader = 63, RULE_result = 64, RULE_methodDeclarator = 65, 
-		RULE_formalParameterList = 66, RULE_formalParameters = 67, RULE_formalParameter = 68, 
-		RULE_variableModifier = 69, RULE_lastFormalParameter = 70, RULE_receiverParameter = 71, 
-		RULE_throws_ = 72, RULE_exceptionTypeList = 73, RULE_exceptionType = 74, 
-		RULE_methodBody = 75, RULE_instanceInitializer = 76, RULE_staticInitializer = 77, 
-		RULE_constructorDeclaration = 78, RULE_constructorModifier = 79, RULE_constructorDeclarator = 80, 
-		RULE_simpleTypeName = 81, RULE_constructorBody = 82, RULE_explicitConstructorInvocation = 83, 
-		RULE_enumDeclaration = 84, RULE_enumBody = 85, RULE_enumConstantList = 86, 
-		RULE_enumConstant = 87, RULE_enumConstantModifier = 88, RULE_enumBodyDeclarations = 89, 
-		RULE_argumentList = 90, RULE_expression = 91, RULE_conditionalExpression = 92, 
-		RULE_primary = 93, RULE_interfaceDeclaration = 94, RULE_normalInterfaceDeclaration = 95, 
-		RULE_interfaceModifier = 96, RULE_extendsInterfaces = 97, RULE_interfaceBody = 98, 
-		RULE_interfaceMemberDeclaration = 99, RULE_constantDeclaration = 100, 
-		RULE_constantModifier = 101, RULE_interfaceMethodDeclaration = 102, RULE_interfaceMethodModifier = 103, 
-		RULE_annotationTypeDeclaration = 104, RULE_annotationTypeBody = 105, RULE_annotation = 106, 
-		RULE_normalAnnotation = 107, RULE_elementValuePairList = 108, RULE_elementValuePair = 109, 
-		RULE_elementValue = 110, RULE_elementValueArrayInitializer = 111, RULE_elementValueList = 112, 
-		RULE_markerAnnotation = 113, RULE_singleElementAnnotation = 114, RULE_arrayInitializer = 115, 
-		RULE_variableInitializerList = 116, RULE_block = 117, RULE_blockStatements = 118;
+		RULE_compilationUnit = 26, RULE_packageDeclaration = 27, RULE_packageModifier = 28, 
+		RULE_importDeclaration = 29, RULE_singleTypeImportDeclaration = 30, RULE_typeImportOnDemandDeclaration = 31, 
+		RULE_singleStaticImportDeclaration = 32, RULE_staticImportOnDemandDeclaration = 33, 
+		RULE_typeDeclaration = 34, RULE_classDeclaration = 35, RULE_normalClassDeclaration = 36, 
+		RULE_classModifier = 37, RULE_typeParameters = 38, RULE_typeParameterList = 39, 
+		RULE_superclass = 40, RULE_superinterfaces = 41, RULE_interfaceTypeList = 42, 
+		RULE_classBody = 43, RULE_classBodyDeclaration = 44, RULE_classMemberDeclaration = 45, 
+		RULE_fieldDeclaration = 46, RULE_fieldModifier = 47, RULE_variableDeclaratorList = 48, 
+		RULE_variableDeclarator = 49, RULE_variableDeclaratorId = 50, RULE_variableInitializer = 51, 
+		RULE_unannType = 52, RULE_unannPrimitiveType = 53, RULE_unannReferenceType = 54, 
+		RULE_unannClassOrInterfaceType = 55, RULE_unannClassType_lf_unannClassOrInterfaceType = 56, 
+		RULE_unannClassType_lfno_unannClassOrInterfaceType = 57, RULE_unannInterfaceType_lf_unannClassOrInterfaceType = 58, 
+		RULE_unannInterfaceType_lfno_unannClassOrInterfaceType = 59, RULE_unannTypeVariable = 60, 
+		RULE_unannArrayType = 61, RULE_methodDeclaration = 62, RULE_methodModifier = 63, 
+		RULE_methodHeader = 64, RULE_result = 65, RULE_methodDeclarator = 66, 
+		RULE_formalParameterList = 67, RULE_formalParameters = 68, RULE_formalParameter = 69, 
+		RULE_variableModifier = 70, RULE_lastFormalParameter = 71, RULE_receiverParameter = 72, 
+		RULE_throws_ = 73, RULE_exceptionTypeList = 74, RULE_exceptionType = 75, 
+		RULE_methodBody = 76, RULE_instanceInitializer = 77, RULE_staticInitializer = 78, 
+		RULE_constructorDeclaration = 79, RULE_constructorModifier = 80, RULE_constructorDeclarator = 81, 
+		RULE_simpleTypeName = 82, RULE_constructorBody = 83, RULE_enumDeclaration = 84, 
+		RULE_enumBody = 85, RULE_enumConstantList = 86, RULE_enumConstant = 87, 
+		RULE_enumConstantModifier = 88, RULE_enumBodyDeclarations = 89, RULE_argumentList = 90, 
+		RULE_expression = 91, RULE_conditionalExpression = 92, RULE_interfaceDeclaration = 93, 
+		RULE_normalInterfaceDeclaration = 94, RULE_interfaceModifier = 95, RULE_extendsInterfaces = 96, 
+		RULE_interfaceBody = 97, RULE_interfaceMemberDeclaration = 98, RULE_constantDeclaration = 99, 
+		RULE_constantModifier = 100, RULE_interfaceMethodDeclaration = 101, RULE_interfaceMethodModifier = 102, 
+		RULE_annotationTypeDeclaration = 103, RULE_annotationTypeBody = 104, RULE_annotation = 105, 
+		RULE_normalAnnotation = 106, RULE_elementValuePairList = 107, RULE_elementValuePair = 108, 
+		RULE_elementValue = 109, RULE_elementValueArrayInitializer = 110, RULE_elementValueList = 111, 
+		RULE_markerAnnotation = 112, RULE_singleElementAnnotation = 113, RULE_arrayInitializer = 114, 
+		RULE_variableInitializerList = 115, RULE_block = 116, RULE_blockStatements = 117;
 	public static final String[] ruleNames = {
 		"primitiveType", "numericType", "integralType", "floatingPointType", "referenceType", 
 		"classOrInterfaceType", "classType", "classType_lf_classOrInterfaceType", 
@@ -87,25 +86,26 @@ public class DroppingJavaParser extends Parser {
 		"interfaceType_lfno_classOrInterfaceType", "typeVariable", "arrayType", 
 		"dims", "typeParameter", "typeParameterModifier", "typeBound", "additionalBound", 
 		"typeArguments", "typeArgumentList", "typeArgument", "wildcard", "wildcardBounds", 
-		"typeName", "packageOrTypeName", "expressionName", "ambiguousName", "compilationUnit", 
-		"packageDeclaration", "packageModifier", "importDeclaration", "singleTypeImportDeclaration", 
+		"typeName", "packageOrTypeName", "compilationUnit", "packageDeclaration", 
+		"packageModifier", "importDeclaration", "singleTypeImportDeclaration", 
 		"typeImportOnDemandDeclaration", "singleStaticImportDeclaration", "staticImportOnDemandDeclaration", 
 		"typeDeclaration", "classDeclaration", "normalClassDeclaration", "classModifier", 
 		"typeParameters", "typeParameterList", "superclass", "superinterfaces", 
 		"interfaceTypeList", "classBody", "classBodyDeclaration", "classMemberDeclaration", 
-		"fieldDeclaration", "variableDeclaratorId", "variableInitializer", "unannType", 
-		"unannPrimitiveType", "unannReferenceType", "unannClassOrInterfaceType", 
-		"unannClassType_lf_unannClassOrInterfaceType", "unannClassType_lfno_unannClassOrInterfaceType", 
-		"unannInterfaceType_lf_unannClassOrInterfaceType", "unannInterfaceType_lfno_unannClassOrInterfaceType", 
-		"unannTypeVariable", "unannArrayType", "methodDeclaration", "methodModifier", 
-		"methodHeader", "result", "methodDeclarator", "formalParameterList", "formalParameters", 
+		"fieldDeclaration", "fieldModifier", "variableDeclaratorList", "variableDeclarator", 
+		"variableDeclaratorId", "variableInitializer", "unannType", "unannPrimitiveType", 
+		"unannReferenceType", "unannClassOrInterfaceType", "unannClassType_lf_unannClassOrInterfaceType", 
+		"unannClassType_lfno_unannClassOrInterfaceType", "unannInterfaceType_lf_unannClassOrInterfaceType", 
+		"unannInterfaceType_lfno_unannClassOrInterfaceType", "unannTypeVariable", 
+		"unannArrayType", "methodDeclaration", "methodModifier", "methodHeader", 
+		"result", "methodDeclarator", "formalParameterList", "formalParameters", 
 		"formalParameter", "variableModifier", "lastFormalParameter", "receiverParameter", 
 		"throws_", "exceptionTypeList", "exceptionType", "methodBody", "instanceInitializer", 
 		"staticInitializer", "constructorDeclaration", "constructorModifier", 
-		"constructorDeclarator", "simpleTypeName", "constructorBody", "explicitConstructorInvocation", 
-		"enumDeclaration", "enumBody", "enumConstantList", "enumConstant", "enumConstantModifier", 
+		"constructorDeclarator", "simpleTypeName", "constructorBody", "enumDeclaration", 
+		"enumBody", "enumConstantList", "enumConstant", "enumConstantModifier", 
 		"enumBodyDeclarations", "argumentList", "expression", "conditionalExpression", 
-		"primary", "interfaceDeclaration", "normalInterfaceDeclaration", "interfaceModifier", 
+		"interfaceDeclaration", "normalInterfaceDeclaration", "interfaceModifier", 
 		"extendsInterfaces", "interfaceBody", "interfaceMemberDeclaration", "constantDeclaration", 
 		"constantModifier", "interfaceMethodDeclaration", "interfaceMethodModifier", 
 		"annotationTypeDeclaration", "annotationTypeBody", "annotation", "normalAnnotation", 
@@ -218,6 +218,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitPrimitiveType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitPrimitiveType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final PrimitiveTypeContext primitiveType() throws RecognitionException {
@@ -225,47 +230,47 @@ public final PrimitiveTypeContext primitiveType() throws RecognitionException {
 		enterRule(_localctx, 0, RULE_primitiveType);
 		int _la;
 		try {
-			setState(252);
+			setState(250);
 			switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(241);
+				setState(239);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 				while (_la==AT) {
 					{
 					{
-					setState(238);
+					setState(236);
 					annotation();
 					}
 					}
-					setState(243);
+					setState(241);
 					_errHandler.sync(this);
 					_la = _input.LA(1);
 				}
-				setState(244);
+				setState(242);
 				numericType();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(248);
+				setState(246);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 				while (_la==AT) {
 					{
 					{
-					setState(245);
+					setState(243);
 					annotation();
 					}
 					}
-					setState(250);
+					setState(248);
 					_errHandler.sync(this);
 					_la = _input.LA(1);
 				}
-				setState(251);
+				setState(249);
 				match(BOOLEAN);
 				}
 				break;
@@ -301,13 +306,18 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitNumericType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitNumericType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final NumericTypeContext numericType() throws RecognitionException {
 		NumericTypeContext _localctx = new NumericTypeContext(_ctx, getState());
 		enterRule(_localctx, 2, RULE_numericType);
 		try {
-			setState(256);
+			setState(254);
 			switch (_input.LA(1)) {
 			case BYTE:
 			case CHAR:
@@ -316,7 +326,7 @@ public final NumericTypeContext numericType() throws RecognitionException {
 			case SHORT:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(254);
+				setState(252);
 				integralType();
 				}
 				break;
@@ -324,7 +334,7 @@ public final NumericTypeContext numericType() throws RecognitionException {
 			case FLOAT:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(255);
+				setState(253);
 				floatingPointType();
 				}
 				break;
@@ -356,6 +366,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitIntegralType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitIntegralType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final IntegralTypeContext integralType() throws RecognitionException {
@@ -365,7 +380,7 @@ public final IntegralTypeContext integralType() throws RecognitionException {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(258);
+			setState(256);
 			_la = _input.LA(1);
 			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BYTE) | (1L << CHAR) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0)) ) {
 			_errHandler.recoverInline(this);
@@ -398,6 +413,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitFloatingPointType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitFloatingPointType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final FloatingPointTypeContext floatingPointType() throws RecognitionException {
@@ -407,7 +427,7 @@ public final FloatingPointTypeContext floatingPointType() throws RecognitionExce
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(260);
+			setState(258);
 			_la = _input.LA(1);
 			if ( !(_la==DOUBLE || _la==FLOAT) ) {
 			_errHandler.recoverInline(this);
@@ -449,32 +469,37 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitReferenceType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitReferenceType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ReferenceTypeContext referenceType() throws RecognitionException {
 		ReferenceTypeContext _localctx = new ReferenceTypeContext(_ctx, getState());
 		enterRule(_localctx, 8, RULE_referenceType);
 		try {
-			setState(265);
+			setState(263);
 			switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(262);
+				setState(260);
 				classOrInterfaceType();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(263);
+				setState(261);
 				typeVariable();
 				}
 				break;
 			case 3:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(264);
+				setState(262);
 				arrayType();
 				}
 				break;
@@ -522,6 +547,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassOrInterfaceType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitClassOrInterfaceType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException {
@@ -531,45 +561,45 @@ public final ClassOrInterfaceTypeContext classOrInterfaceType() throws Recogniti
 			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(269);
+			setState(267);
 			switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
 			case 1:
 				{
-				setState(267);
+				setState(265);
 				classType_lfno_classOrInterfaceType();
 				}
 				break;
 			case 2:
 				{
-				setState(268);
+				setState(266);
 				interfaceType_lfno_classOrInterfaceType();
 				}
 				break;
 			}
-			setState(275);
+			setState(273);
 			_errHandler.sync(this);
 			_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 				if ( _alt==1 ) {
 					{
-					setState(273);
+					setState(271);
 					switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
 					case 1:
 						{
-						setState(271);
+						setState(269);
 						classType_lf_classOrInterfaceType();
 						}
 						break;
 					case 2:
 						{
-						setState(272);
+						setState(270);
 						interfaceType_lf_classOrInterfaceType();
 						}
 						break;
 					}
 					} 
 				}
-				setState(277);
+				setState(275);
 				_errHandler.sync(this);
 				_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
 			}
@@ -612,6 +642,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitClassType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ClassTypeContext classType() throws RecognitionException {
@@ -619,32 +654,32 @@ public final ClassTypeContext classType() throws RecognitionException {
 		enterRule(_localctx, 12, RULE_classType);
 		int _la;
 		try {
-			setState(300);
+			setState(298);
 			switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(281);
+				setState(279);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 				while (_la==AT) {
 					{
 					{
-					setState(278);
+					setState(276);
 					annotation();
 					}
 					}
-					setState(283);
+					setState(281);
 					_errHandler.sync(this);
 					_la = _input.LA(1);
 				}
-				setState(284);
+				setState(282);
 				match(Identifier);
-				setState(286);
+				setState(284);
 				_la = _input.LA(1);
 				if (_la==LT) {
 					{
-					setState(285);
+					setState(283);
 					typeArguments();
 					}
 				}
@@ -654,31 +689,31 @@ public final ClassTypeContext classType() throws RecognitionException {
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(288);
+				setState(286);
 				classOrInterfaceType();
-				setState(289);
+				setState(287);
 				match(DOT);
-				setState(293);
+				setState(291);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 				while (_la==AT) {
 					{
 					{
-					setState(290);
+					setState(288);
 					annotation();
 					}
 					}
-					setState(295);
+					setState(293);
 					_errHandler.sync(this);
 					_la = _input.LA(1);
 				}
-				setState(296);
+				setState(294);
 				match(Identifier);
-				setState(298);
+				setState(296);
 				_la = _input.LA(1);
 				if (_la==LT) {
 					{
-					setState(297);
+					setState(295);
 					typeArguments();
 					}
 				}
@@ -721,6 +756,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassType_lf_classOrInterfaceType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitClassType_lf_classOrInterfaceType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() throws RecognitionException {
@@ -730,29 +770,29 @@ public final ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterf
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(302);
+			setState(300);
 			match(DOT);
-			setState(306);
+			setState(304);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==AT) {
 				{
 				{
-				setState(303);
+				setState(301);
 				annotation();
 				}
 				}
-				setState(308);
+				setState(306);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(309);
+			setState(307);
 			match(Identifier);
-			setState(311);
+			setState(309);
 			_la = _input.LA(1);
 			if (_la==LT) {
 				{
-				setState(310);
+				setState(308);
 				typeArguments();
 				}
 			}
@@ -793,6 +833,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassType_lfno_classOrInterfaceType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitClassType_lfno_classOrInterfaceType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() throws RecognitionException {
@@ -802,27 +847,27 @@ public final ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrIn
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(316);
+			setState(314);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==AT) {
 				{
 				{
-				setState(313);
+				setState(311);
 				annotation();
 				}
 				}
-				setState(318);
+				setState(316);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(319);
+			setState(317);
 			match(Identifier);
-			setState(321);
+			setState(319);
 			_la = _input.LA(1);
 			if (_la==LT) {
 				{
-				setState(320);
+				setState(318);
 				typeArguments();
 				}
 			}
@@ -856,6 +901,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitInterfaceType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final InterfaceTypeContext interfaceType() throws RecognitionException {
@@ -864,7 +914,7 @@ public final InterfaceTypeContext interfaceType() throws RecognitionException {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(323);
+			setState(321);
 			classType();
 			}
 		}
@@ -895,6 +945,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceType_lf_classOrInterfaceType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitInterfaceType_lf_classOrInterfaceType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType() throws RecognitionException {
@@ -903,7 +958,7 @@ public final InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_class
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(325);
+			setState(323);
 			classType_lf_classOrInterfaceType();
 			}
 		}
@@ -934,6 +989,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceType_lfno_classOrInterfaceType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitInterfaceType_lfno_classOrInterfaceType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() throws RecognitionException {
@@ -942,7 +1002,7 @@ public final InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_c
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(327);
+			setState(325);
 			classType_lfno_classOrInterfaceType();
 			}
 		}
@@ -977,6 +1037,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeVariable(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitTypeVariable(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final TypeVariableContext typeVariable() throws RecognitionException {
@@ -986,21 +1051,21 @@ public final TypeVariableContext typeVariable() throws RecognitionException {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(332);
+			setState(330);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==AT) {
 				{
 				{
-				setState(329);
+				setState(327);
 				annotation();
 				}
 				}
-				setState(334);
+				setState(332);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(335);
+			setState(333);
 			match(Identifier);
 			}
 		}
@@ -1040,38 +1105,43 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitArrayType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitArrayType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ArrayTypeContext arrayType() throws RecognitionException {
 		ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState());
 		enterRule(_localctx, 26, RULE_arrayType);
 		try {
-			setState(346);
+			setState(344);
 			switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(337);
+				setState(335);
 				primitiveType();
-				setState(338);
+				setState(336);
 				dims();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(340);
+				setState(338);
 				classOrInterfaceType();
-				setState(341);
+				setState(339);
 				dims();
 				}
 				break;
 			case 3:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(343);
+				setState(341);
 				typeVariable();
-				setState(344);
+				setState(342);
 				dims();
 				}
 				break;
@@ -1107,6 +1177,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitDims(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitDims(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final DimsContext dims() throws RecognitionException {
@@ -1117,53 +1192,53 @@ public final DimsContext dims() throws RecognitionException {
 			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(351);
+			setState(349);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==AT) {
 				{
 				{
-				setState(348);
+				setState(346);
 				annotation();
 				}
 				}
-				setState(353);
+				setState(351);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(354);
+			setState(352);
 			match(LBRACK);
-			setState(355);
+			setState(353);
 			match(RBRACK);
-			setState(366);
+			setState(364);
 			_errHandler.sync(this);
 			_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 				if ( _alt==1 ) {
 					{
 					{
-					setState(359);
+					setState(357);
 					_errHandler.sync(this);
 					_la = _input.LA(1);
 					while (_la==AT) {
 						{
 						{
-						setState(356);
+						setState(354);
 						annotation();
 						}
 						}
-						setState(361);
+						setState(359);
 						_errHandler.sync(this);
 						_la = _input.LA(1);
 					}
-					setState(362);
+					setState(360);
 					match(LBRACK);
-					setState(363);
+					setState(361);
 					match(RBRACK);
 					}
 					} 
 				}
-				setState(368);
+				setState(366);
 				_errHandler.sync(this);
 				_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
 			}
@@ -1203,6 +1278,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeParameter(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitTypeParameter(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final TypeParameterContext typeParameter() throws RecognitionException {
@@ -1212,27 +1292,27 @@ public final TypeParameterContext typeParameter() throws RecognitionException {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(372);
+			setState(370);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==AT) {
 				{
 				{
-				setState(369);
+				setState(367);
 				typeParameterModifier();
 				}
 				}
-				setState(374);
+				setState(372);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(375);
+			setState(373);
 			match(Identifier);
-			setState(377);
+			setState(375);
 			_la = _input.LA(1);
 			if (_la==EXTENDS) {
 				{
-				setState(376);
+				setState(374);
 				typeBound();
 				}
 			}
@@ -1266,6 +1346,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeParameterModifier(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitTypeParameterModifier(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final TypeParameterModifierContext typeParameterModifier() throws RecognitionException {
@@ -1274,7 +1359,7 @@ public final TypeParameterModifierContext typeParameterModifier() throws Recogni
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(379);
+			setState(377);
 			annotation();
 			}
 		}
@@ -1314,6 +1399,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeBound(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitTypeBound(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final TypeBoundContext typeBound() throws RecognitionException {
@@ -1321,35 +1411,35 @@ public final TypeBoundContext typeBound() throws RecognitionException {
 		enterRule(_localctx, 34, RULE_typeBound);
 		int _la;
 		try {
-			setState(391);
+			setState(389);
 			switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(381);
+				setState(379);
 				match(EXTENDS);
-				setState(382);
+				setState(380);
 				typeVariable();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(383);
+				setState(381);
 				match(EXTENDS);
-				setState(384);
+				setState(382);
 				classOrInterfaceType();
-				setState(388);
+				setState(386);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 				while (_la==BITAND) {
 					{
 					{
-					setState(385);
+					setState(383);
 					additionalBound();
 					}
 					}
-					setState(390);
+					setState(388);
 					_errHandler.sync(this);
 					_la = _input.LA(1);
 				}
@@ -1384,6 +1474,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitAdditionalBound(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitAdditionalBound(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final AdditionalBoundContext additionalBound() throws RecognitionException {
@@ -1392,9 +1487,9 @@ public final AdditionalBoundContext additionalBound() throws RecognitionExceptio
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(393);
+			setState(391);
 			match(BITAND);
-			setState(394);
+			setState(392);
 			interfaceType();
 			}
 		}
@@ -1425,6 +1520,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeArguments(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitTypeArguments(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final TypeArgumentsContext typeArguments() throws RecognitionException {
@@ -1433,11 +1533,11 @@ public final TypeArgumentsContext typeArguments() throws RecognitionException {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(396);
+			setState(394);
 			match(LT);
-			setState(397);
+			setState(395);
 			typeArgumentList();
-			setState(398);
+			setState(396);
 			match(GT);
 			}
 		}
@@ -1471,6 +1571,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeArgumentList(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitTypeArgumentList(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final TypeArgumentListContext typeArgumentList() throws RecognitionException {
@@ -1480,21 +1585,21 @@ public final TypeArgumentListContext typeArgumentList() throws RecognitionExcept
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(400);
+			setState(398);
 			typeArgument();
-			setState(405);
+			setState(403);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==COMMA) {
 				{
 				{
-				setState(401);
+				setState(399);
 				match(COMMA);
-				setState(402);
+				setState(400);
 				typeArgument();
 				}
 				}
-				setState(407);
+				setState(405);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
@@ -1530,25 +1635,30 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeArgument(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitTypeArgument(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final TypeArgumentContext typeArgument() throws RecognitionException {
 		TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState());
 		enterRule(_localctx, 42, RULE_typeArgument);
 		try {
-			setState(410);
+			setState(408);
 			switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(408);
+				setState(406);
 				referenceType();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(409);
+				setState(407);
 				wildcard();
 				}
 				break;
@@ -1587,6 +1697,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitWildcard(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitWildcard(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final WildcardContext wildcard() throws RecognitionException {
@@ -1596,27 +1711,27 @@ public final WildcardContext wildcard() throws RecognitionException {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(415);
+			setState(413);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==AT) {
 				{
 				{
-				setState(412);
+				setState(410);
 				annotation();
 				}
 				}
-				setState(417);
+				setState(415);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(418);
+			setState(416);
 			match(QUESTION);
-			setState(420);
+			setState(418);
 			_la = _input.LA(1);
 			if (_la==EXTENDS || _la==SUPER) {
 				{
-				setState(419);
+				setState(417);
 				wildcardBounds();
 				}
 			}
@@ -1650,29 +1765,34 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitWildcardBounds(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitWildcardBounds(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final WildcardBoundsContext wildcardBounds() throws RecognitionException {
 		WildcardBoundsContext _localctx = new WildcardBoundsContext(_ctx, getState());
 		enterRule(_localctx, 46, RULE_wildcardBounds);
 		try {
-			setState(426);
+			setState(424);
 			switch (_input.LA(1)) {
 			case EXTENDS:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(422);
+				setState(420);
 				match(EXTENDS);
-				setState(423);
+				setState(421);
 				referenceType();
 				}
 				break;
 			case SUPER:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(424);
+				setState(422);
 				match(SUPER);
-				setState(425);
+				setState(423);
 				referenceType();
 				}
 				break;
@@ -1708,29 +1828,34 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeName(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitTypeName(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final TypeNameContext typeName() throws RecognitionException {
 		TypeNameContext _localctx = new TypeNameContext(_ctx, getState());
 		enterRule(_localctx, 48, RULE_typeName);
 		try {
-			setState(433);
+			setState(431);
 			switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(428);
+				setState(426);
 				match(Identifier);
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(429);
+				setState(427);
 				packageOrTypeName(0);
-				setState(430);
+				setState(428);
 				match(DOT);
-				setState(431);
+				setState(429);
 				match(Identifier);
 				}
 				break;
@@ -1764,6 +1889,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitPackageOrTypeName(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitPackageOrTypeName(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final PackageOrTypeNameContext packageOrTypeName() throws RecognitionException {
@@ -1782,11 +1912,11 @@ private PackageOrTypeNameContext packageOrTypeName(int _p) throws RecognitionExc
 			enterOuterAlt(_localctx, 1);
 			{
 			{
-			setState(436);
+			setState(434);
 			match(Identifier);
 			}
 			_ctx.stop = _input.LT(-1);
-			setState(443);
+			setState(441);
 			_errHandler.sync(this);
 			_alt = getInterpreter().adaptivePredict(_input,32,_ctx);
 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
@@ -1797,16 +1927,16 @@ private PackageOrTypeNameContext packageOrTypeName(int _p) throws RecognitionExc
 					{
 					_localctx = new PackageOrTypeNameContext(_parentctx, _parentState);
 					pushNewRecursionContext(_localctx, _startState, RULE_packageOrTypeName);
-					setState(438);
+					setState(436);
 					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
-					setState(439);
+					setState(437);
 					match(DOT);
-					setState(440);
+					setState(438);
 					match(Identifier);
 					}
 					} 
 				}
-				setState(445);
+				setState(443);
 				_errHandler.sync(this);
 				_alt = getInterpreter().adaptivePredict(_input,32,_ctx);
 			}
@@ -1823,138 +1953,6 @@ private PackageOrTypeNameContext packageOrTypeName(int _p) throws RecognitionExc
 		return _localctx;
 	}
 
-	public static class ExpressionNameContext extends ParserRuleContext {
-		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
-		public AmbiguousNameContext ambiguousName() {
-			return getRuleContext(AmbiguousNameContext.class,0);
-		}
-		public ExpressionNameContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_expressionName; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterExpressionName(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitExpressionName(this);
-		}
-	}
-
-	public final ExpressionNameContext expressionName() throws RecognitionException {
-		ExpressionNameContext _localctx = new ExpressionNameContext(_ctx, getState());
-		enterRule(_localctx, 52, RULE_expressionName);
-		try {
-			setState(451);
-			switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
-			case 1:
-				enterOuterAlt(_localctx, 1);
-				{
-				setState(446);
-				match(Identifier);
-				}
-				break;
-			case 2:
-				enterOuterAlt(_localctx, 2);
-				{
-				setState(447);
-				ambiguousName(0);
-				setState(448);
-				match(DOT);
-				setState(449);
-				match(Identifier);
-				}
-				break;
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class AmbiguousNameContext extends ParserRuleContext {
-		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
-		public AmbiguousNameContext ambiguousName() {
-			return getRuleContext(AmbiguousNameContext.class,0);
-		}
-		public AmbiguousNameContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_ambiguousName; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterAmbiguousName(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitAmbiguousName(this);
-		}
-	}
-
-	public final AmbiguousNameContext ambiguousName() throws RecognitionException {
-		return ambiguousName(0);
-	}
-
-	private AmbiguousNameContext ambiguousName(int _p) throws RecognitionException {
-		ParserRuleContext _parentctx = _ctx;
-		int _parentState = getState();
-		AmbiguousNameContext _localctx = new AmbiguousNameContext(_ctx, _parentState);
-		AmbiguousNameContext _prevctx = _localctx;
-		int _startState = 54;
-		enterRecursionRule(_localctx, 54, RULE_ambiguousName, _p);
-		try {
-			int _alt;
-			enterOuterAlt(_localctx, 1);
-			{
-			{
-			setState(454);
-			match(Identifier);
-			}
-			_ctx.stop = _input.LT(-1);
-			setState(461);
-			_errHandler.sync(this);
-			_alt = getInterpreter().adaptivePredict(_input,34,_ctx);
-			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
-				if ( _alt==1 ) {
-					if ( _parseListeners!=null ) triggerExitRuleEvent();
-					_prevctx = _localctx;
-					{
-					{
-					_localctx = new AmbiguousNameContext(_parentctx, _parentState);
-					pushNewRecursionContext(_localctx, _startState, RULE_ambiguousName);
-					setState(456);
-					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
-					setState(457);
-					match(DOT);
-					setState(458);
-					match(Identifier);
-					}
-					} 
-				}
-				setState(463);
-				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,34,_ctx);
-			}
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			unrollRecursionContexts(_parentctx);
-		}
-		return _localctx;
-	}
-
 	public static class CompilationUnitContext extends ParserRuleContext {
 		public TerminalNode EOF() { return getToken(DroppingJavaParser.EOF, 0); }
 		public PackageDeclarationContext packageDeclaration() {
@@ -1984,53 +1982,58 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitCompilationUnit(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitCompilationUnit(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final CompilationUnitContext compilationUnit() throws RecognitionException {
 		CompilationUnitContext _localctx = new CompilationUnitContext(_ctx, getState());
-		enterRule(_localctx, 56, RULE_compilationUnit);
+		enterRule(_localctx, 52, RULE_compilationUnit);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(465);
-			switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
+			setState(445);
+			switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
 			case 1:
 				{
-				setState(464);
+				setState(444);
 				packageDeclaration();
 				}
 				break;
 			}
-			setState(470);
+			setState(450);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==IMPORT) {
 				{
 				{
-				setState(467);
+				setState(447);
 				importDeclaration();
 				}
 				}
-				setState(472);
+				setState(452);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(476);
+			setState(456);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << CLASS) | (1L << ENUM) | (1L << FINAL) | (1L << INTERFACE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP) | (1L << SEMI))) != 0) || _la==AT) {
 				{
 				{
-				setState(473);
+				setState(453);
 				typeDeclaration();
 				}
 				}
-				setState(478);
+				setState(458);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(479);
+			setState(459);
 			match(EOF);
 			}
 		}
@@ -2068,50 +2071,55 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitPackageDeclaration(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitPackageDeclaration(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final PackageDeclarationContext packageDeclaration() throws RecognitionException {
 		PackageDeclarationContext _localctx = new PackageDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 58, RULE_packageDeclaration);
+		enterRule(_localctx, 54, RULE_packageDeclaration);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(484);
+			setState(464);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==AT) {
 				{
 				{
-				setState(481);
+				setState(461);
 				packageModifier();
 				}
 				}
-				setState(486);
+				setState(466);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(487);
+			setState(467);
 			match(PACKAGE);
-			setState(488);
+			setState(468);
 			match(Identifier);
-			setState(493);
+			setState(473);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==DOT) {
 				{
 				{
-				setState(489);
+				setState(469);
 				match(DOT);
-				setState(490);
+				setState(470);
 				match(Identifier);
 				}
 				}
-				setState(495);
+				setState(475);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(496);
+			setState(476);
 			match(SEMI);
 			}
 		}
@@ -2142,15 +2150,20 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitPackageModifier(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitPackageModifier(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final PackageModifierContext packageModifier() throws RecognitionException {
 		PackageModifierContext _localctx = new PackageModifierContext(_ctx, getState());
-		enterRule(_localctx, 60, RULE_packageModifier);
+		enterRule(_localctx, 56, RULE_packageModifier);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(498);
+			setState(478);
 			annotation();
 			}
 		}
@@ -2190,39 +2203,44 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitImportDeclaration(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitImportDeclaration(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ImportDeclarationContext importDeclaration() throws RecognitionException {
 		ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 62, RULE_importDeclaration);
+		enterRule(_localctx, 58, RULE_importDeclaration);
 		try {
-			setState(504);
-			switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
+			setState(484);
+			switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(500);
+				setState(480);
 				singleTypeImportDeclaration();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(501);
+				setState(481);
 				typeImportOnDemandDeclaration();
 				}
 				break;
 			case 3:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(502);
+				setState(482);
 				singleStaticImportDeclaration();
 				}
 				break;
 			case 4:
 				enterOuterAlt(_localctx, 4);
 				{
-				setState(503);
+				setState(483);
 				staticImportOnDemandDeclaration();
 				}
 				break;
@@ -2255,19 +2273,24 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitSingleTypeImportDeclaration(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitSingleTypeImportDeclaration(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final SingleTypeImportDeclarationContext singleTypeImportDeclaration() throws RecognitionException {
 		SingleTypeImportDeclarationContext _localctx = new SingleTypeImportDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 64, RULE_singleTypeImportDeclaration);
+		enterRule(_localctx, 60, RULE_singleTypeImportDeclaration);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(506);
+			setState(486);
 			match(IMPORT);
-			setState(507);
+			setState(487);
 			typeName();
-			setState(508);
+			setState(488);
 			match(SEMI);
 			}
 		}
@@ -2298,23 +2321,28 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeImportOnDemandDeclaration(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitTypeImportOnDemandDeclaration(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() throws RecognitionException {
 		TypeImportOnDemandDeclarationContext _localctx = new TypeImportOnDemandDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 66, RULE_typeImportOnDemandDeclaration);
+		enterRule(_localctx, 62, RULE_typeImportOnDemandDeclaration);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(510);
+			setState(490);
 			match(IMPORT);
-			setState(511);
+			setState(491);
 			packageOrTypeName(0);
-			setState(512);
+			setState(492);
 			match(DOT);
-			setState(513);
+			setState(493);
 			match(MUL);
-			setState(514);
+			setState(494);
 			match(SEMI);
 			}
 		}
@@ -2346,25 +2374,30 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitSingleStaticImportDeclaration(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitSingleStaticImportDeclaration(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final SingleStaticImportDeclarationContext singleStaticImportDeclaration() throws RecognitionException {
 		SingleStaticImportDeclarationContext _localctx = new SingleStaticImportDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 68, RULE_singleStaticImportDeclaration);
+		enterRule(_localctx, 64, RULE_singleStaticImportDeclaration);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(516);
+			setState(496);
 			match(IMPORT);
-			setState(517);
+			setState(497);
 			match(STATIC);
-			setState(518);
+			setState(498);
 			typeName();
-			setState(519);
+			setState(499);
 			match(DOT);
-			setState(520);
+			setState(500);
 			match(Identifier);
-			setState(521);
+			setState(501);
 			match(SEMI);
 			}
 		}
@@ -2395,25 +2428,30 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitStaticImportOnDemandDeclaration(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitStaticImportOnDemandDeclaration(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() throws RecognitionException {
 		StaticImportOnDemandDeclarationContext _localctx = new StaticImportOnDemandDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 70, RULE_staticImportOnDemandDeclaration);
+		enterRule(_localctx, 66, RULE_staticImportOnDemandDeclaration);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(523);
+			setState(503);
 			match(IMPORT);
-			setState(524);
+			setState(504);
 			match(STATIC);
-			setState(525);
+			setState(505);
 			typeName();
-			setState(526);
+			setState(506);
 			match(DOT);
-			setState(527);
+			setState(507);
 			match(MUL);
-			setState(528);
+			setState(508);
 			match(SEMI);
 			}
 		}
@@ -2447,32 +2485,37 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeDeclaration(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitTypeDeclaration(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final TypeDeclarationContext typeDeclaration() throws RecognitionException {
 		TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 72, RULE_typeDeclaration);
+		enterRule(_localctx, 68, RULE_typeDeclaration);
 		try {
-			setState(533);
-			switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
+			setState(513);
+			switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(530);
+				setState(510);
 				classDeclaration();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(531);
+				setState(511);
 				interfaceDeclaration();
 				}
 				break;
 			case 3:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(532);
+				setState(512);
 				match(SEMI);
 				}
 				break;
@@ -2508,25 +2551,30 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassDeclaration(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitClassDeclaration(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ClassDeclarationContext classDeclaration() throws RecognitionException {
 		ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 74, RULE_classDeclaration);
+		enterRule(_localctx, 70, RULE_classDeclaration);
 		try {
-			setState(537);
-			switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
+			setState(517);
+			switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(535);
+				setState(515);
 				normalClassDeclaration();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(536);
+				setState(516);
 				enumDeclaration();
 				}
 				break;
@@ -2544,17 +2592,6 @@ public final ClassDeclarationContext classDeclaration() throws RecognitionExcept
 	}
 
 	public static class NormalClassDeclarationContext extends ParserRuleContext {
-		public NormalClassDeclarationContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_normalClassDeclaration; }
-	 
-		public NormalClassDeclarationContext() { }
-		public void copyFrom(NormalClassDeclarationContext ctx) {
-			super.copyFrom(ctx);
-		}
-	}
-	public static class ClassNameContext extends NormalClassDeclarationContext {
 		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
 		public ClassBodyContext classBody() {
 			return getRuleContext(ClassBodyContext.class,0);
@@ -2574,71 +2611,78 @@ public SuperclassContext superclass() {
 		public SuperinterfacesContext superinterfaces() {
 			return getRuleContext(SuperinterfacesContext.class,0);
 		}
-		public ClassNameContext(NormalClassDeclarationContext ctx) { copyFrom(ctx); }
+		public NormalClassDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_normalClassDeclaration; }
 		@Override
 		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterClassName(this);
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterNormalClassDeclaration(this);
 		}
 		@Override
 		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassName(this);
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitNormalClassDeclaration(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitNormalClassDeclaration(this);
+			else return visitor.visitChildren(this);
 		}
 	}
 
 	public final NormalClassDeclarationContext normalClassDeclaration() throws RecognitionException {
 		NormalClassDeclarationContext _localctx = new NormalClassDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 76, RULE_normalClassDeclaration);
+		enterRule(_localctx, 72, RULE_normalClassDeclaration);
 		int _la;
 		try {
-			_localctx = new ClassNameContext(_localctx);
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(542);
+			setState(522);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
 				{
 				{
-				setState(539);
+				setState(519);
 				classModifier();
 				}
 				}
-				setState(544);
+				setState(524);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(545);
+			setState(525);
 			match(CLASS);
-			setState(546);
+			setState(526);
 			match(Identifier);
-			setState(548);
+			setState(528);
 			_la = _input.LA(1);
 			if (_la==LT) {
 				{
-				setState(547);
+				setState(527);
 				typeParameters();
 				}
 			}
 
-			setState(551);
+			setState(531);
 			_la = _input.LA(1);
 			if (_la==EXTENDS) {
 				{
-				setState(550);
+				setState(530);
 				superclass();
 				}
 			}
 
-			setState(554);
+			setState(534);
 			_la = _input.LA(1);
 			if (_la==IMPLEMENTS) {
 				{
-				setState(553);
+				setState(533);
 				superinterfaces();
 				}
 			}
 
-			setState(556);
+			setState(536);
 			classBody();
 			}
 		}
@@ -2669,67 +2713,72 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassModifier(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitClassModifier(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ClassModifierContext classModifier() throws RecognitionException {
 		ClassModifierContext _localctx = new ClassModifierContext(_ctx, getState());
-		enterRule(_localctx, 78, RULE_classModifier);
+		enterRule(_localctx, 74, RULE_classModifier);
 		try {
-			setState(566);
+			setState(546);
 			switch (_input.LA(1)) {
 			case AT:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(558);
+				setState(538);
 				annotation();
 				}
 				break;
 			case PUBLIC:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(559);
+				setState(539);
 				match(PUBLIC);
 				}
 				break;
 			case PROTECTED:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(560);
+				setState(540);
 				match(PROTECTED);
 				}
 				break;
 			case PRIVATE:
 				enterOuterAlt(_localctx, 4);
 				{
-				setState(561);
+				setState(541);
 				match(PRIVATE);
 				}
 				break;
 			case ABSTRACT:
 				enterOuterAlt(_localctx, 5);
 				{
-				setState(562);
+				setState(542);
 				match(ABSTRACT);
 				}
 				break;
 			case STATIC:
 				enterOuterAlt(_localctx, 6);
 				{
-				setState(563);
+				setState(543);
 				match(STATIC);
 				}
 				break;
 			case FINAL:
 				enterOuterAlt(_localctx, 7);
 				{
-				setState(564);
+				setState(544);
 				match(FINAL);
 				}
 				break;
 			case STRICTFP:
 				enterOuterAlt(_localctx, 8);
 				{
-				setState(565);
+				setState(545);
 				match(STRICTFP);
 				}
 				break;
@@ -2764,19 +2813,24 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeParameters(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitTypeParameters(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final TypeParametersContext typeParameters() throws RecognitionException {
 		TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState());
-		enterRule(_localctx, 80, RULE_typeParameters);
+		enterRule(_localctx, 76, RULE_typeParameters);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(568);
+			setState(548);
 			match(LT);
-			setState(569);
+			setState(549);
 			typeParameterList();
-			setState(570);
+			setState(550);
 			match(GT);
 			}
 		}
@@ -2810,30 +2864,35 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitTypeParameterList(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitTypeParameterList(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final TypeParameterListContext typeParameterList() throws RecognitionException {
 		TypeParameterListContext _localctx = new TypeParameterListContext(_ctx, getState());
-		enterRule(_localctx, 82, RULE_typeParameterList);
+		enterRule(_localctx, 78, RULE_typeParameterList);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(572);
+			setState(552);
 			typeParameter();
-			setState(577);
+			setState(557);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==COMMA) {
 				{
 				{
-				setState(573);
+				setState(553);
 				match(COMMA);
-				setState(574);
+				setState(554);
 				typeParameter();
 				}
 				}
-				setState(579);
+				setState(559);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
@@ -2866,17 +2925,22 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitSuperclass(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitSuperclass(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final SuperclassContext superclass() throws RecognitionException {
 		SuperclassContext _localctx = new SuperclassContext(_ctx, getState());
-		enterRule(_localctx, 84, RULE_superclass);
+		enterRule(_localctx, 80, RULE_superclass);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(580);
+			setState(560);
 			match(EXTENDS);
-			setState(581);
+			setState(561);
 			classType();
 			}
 		}
@@ -2907,17 +2971,22 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitSuperinterfaces(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitSuperinterfaces(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final SuperinterfacesContext superinterfaces() throws RecognitionException {
 		SuperinterfacesContext _localctx = new SuperinterfacesContext(_ctx, getState());
-		enterRule(_localctx, 86, RULE_superinterfaces);
+		enterRule(_localctx, 82, RULE_superinterfaces);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(583);
+			setState(563);
 			match(IMPLEMENTS);
-			setState(584);
+			setState(564);
 			interfaceTypeList();
 			}
 		}
@@ -2951,30 +3020,35 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceTypeList(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitInterfaceTypeList(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final InterfaceTypeListContext interfaceTypeList() throws RecognitionException {
 		InterfaceTypeListContext _localctx = new InterfaceTypeListContext(_ctx, getState());
-		enterRule(_localctx, 88, RULE_interfaceTypeList);
+		enterRule(_localctx, 84, RULE_interfaceTypeList);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(586);
+			setState(566);
 			interfaceType();
-			setState(591);
+			setState(571);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==COMMA) {
 				{
 				{
-				setState(587);
+				setState(567);
 				match(COMMA);
-				setState(588);
+				setState(568);
 				interfaceType();
 				}
 				}
-				setState(593);
+				setState(573);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
@@ -3010,34 +3084,37 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassBody(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitClassBody(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ClassBodyContext classBody() throws RecognitionException {
 		ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState());
-		enterRule(_localctx, 90, RULE_classBody);
+		enterRule(_localctx, 86, RULE_classBody);
+		int _la;
 		try {
-			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(594);
+			setState(574);
 			match(LBRACE);
-			setState(598);
+			setState(578);
 			_errHandler.sync(this);
-			_alt = getInterpreter().adaptivePredict(_input,50,_ctx);
-			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
-				if ( _alt==1 ) {
-					{
-					{
-					setState(595);
-					classBodyDeclaration();
-					}
-					} 
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE) | (1L << LBRACE) | (1L << SEMI))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - 68)) | (1L << (Identifier - 68)) | (1L << (AT - 68)))) != 0)) {
+				{
+				{
+				setState(575);
+				classBodyDeclaration();
+				}
 				}
-				setState(600);
+				setState(580);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,50,_ctx);
+				_la = _input.LA(1);
 			}
-			setState(601);
+			setState(581);
 			match(RBRACE);
 			}
 		}
@@ -3077,39 +3154,44 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassBodyDeclaration(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitClassBodyDeclaration(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException {
 		ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 92, RULE_classBodyDeclaration);
+		enterRule(_localctx, 88, RULE_classBodyDeclaration);
 		try {
-			setState(607);
-			switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
+			setState(587);
+			switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(603);
+				setState(583);
 				classMemberDeclaration();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(604);
+				setState(584);
 				instanceInitializer();
 				}
 				break;
 			case 3:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(605);
+				setState(585);
 				staticInitializer();
 				}
 				break;
 			case 4:
 				enterOuterAlt(_localctx, 4);
 				{
-				setState(606);
+				setState(586);
 				constructorDeclaration();
 				}
 				break;
@@ -3151,46 +3233,51 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitClassMemberDeclaration(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitClassMemberDeclaration(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ClassMemberDeclarationContext classMemberDeclaration() throws RecognitionException {
 		ClassMemberDeclarationContext _localctx = new ClassMemberDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 94, RULE_classMemberDeclaration);
+		enterRule(_localctx, 90, RULE_classMemberDeclaration);
 		try {
-			setState(614);
-			switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
+			setState(594);
+			switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(609);
+				setState(589);
 				fieldDeclaration();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(610);
+				setState(590);
 				methodDeclaration();
 				}
 				break;
 			case 3:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(611);
+				setState(591);
 				classDeclaration();
 				}
 				break;
 			case 4:
 				enterOuterAlt(_localctx, 4);
 				{
-				setState(612);
+				setState(592);
 				interfaceDeclaration();
 				}
 				break;
 			case 5:
 				enterOuterAlt(_localctx, 5);
 				{
-				setState(613);
+				setState(593);
 				match(SEMI);
 				}
 				break;
@@ -3208,6 +3295,18 @@ public final ClassMemberDeclarationContext classMemberDeclaration() throws Recog
 	}
 
 	public static class FieldDeclarationContext extends ParserRuleContext {
+		public UnannTypeContext unannType() {
+			return getRuleContext(UnannTypeContext.class,0);
+		}
+		public VariableDeclaratorListContext variableDeclaratorList() {
+			return getRuleContext(VariableDeclaratorListContext.class,0);
+		}
+		public List<FieldModifierContext> fieldModifier() {
+			return getRuleContexts(FieldModifierContext.class);
+		}
+		public FieldModifierContext fieldModifier(int i) {
+			return getRuleContext(FieldModifierContext.class,i);
+		}
 		public FieldDeclarationContext(ParserRuleContext parent, int invokingState) {
 			super(parent, invokingState);
 		}
@@ -3220,36 +3319,39 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitFieldDeclaration(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitFieldDeclaration(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final FieldDeclarationContext fieldDeclaration() throws RecognitionException {
 		FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 96, RULE_fieldDeclaration);
+		enterRule(_localctx, 92, RULE_fieldDeclaration);
+		int _la;
 		try {
-			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(617); 
+			setState(599);
 			_errHandler.sync(this);
-			_alt = 1+1;
-			do {
-				switch (_alt) {
-				case 1+1:
-					{
-					{
-					setState(616);
-					matchWildcard();
-					}
-					}
-					break;
-				default:
-					throw new NoViableAltException(this);
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << TRANSIENT) | (1L << VOLATILE))) != 0) || _la==AT) {
+				{
+				{
+				setState(596);
+				fieldModifier();
+				}
 				}
-				setState(619); 
+				setState(601);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,53,_ctx);
-			} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
-			setState(621);
+				_la = _input.LA(1);
+			}
+			setState(602);
+			unannType();
+			setState(603);
+			variableDeclaratorList();
+			setState(604);
 			match(SEMI);
 			}
 		}
@@ -3264,6 +3366,229 @@ public final FieldDeclarationContext fieldDeclaration() throws RecognitionExcept
 		return _localctx;
 	}
 
+	public static class FieldModifierContext extends ParserRuleContext {
+		public AnnotationContext annotation() {
+			return getRuleContext(AnnotationContext.class,0);
+		}
+		public FieldModifierContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_fieldModifier; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterFieldModifier(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitFieldModifier(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitFieldModifier(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final FieldModifierContext fieldModifier() throws RecognitionException {
+		FieldModifierContext _localctx = new FieldModifierContext(_ctx, getState());
+		enterRule(_localctx, 94, RULE_fieldModifier);
+		try {
+			setState(614);
+			switch (_input.LA(1)) {
+			case AT:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(606);
+				annotation();
+				}
+				break;
+			case PUBLIC:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(607);
+				match(PUBLIC);
+				}
+				break;
+			case PROTECTED:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(608);
+				match(PROTECTED);
+				}
+				break;
+			case PRIVATE:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(609);
+				match(PRIVATE);
+				}
+				break;
+			case STATIC:
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(610);
+				match(STATIC);
+				}
+				break;
+			case FINAL:
+				enterOuterAlt(_localctx, 6);
+				{
+				setState(611);
+				match(FINAL);
+				}
+				break;
+			case TRANSIENT:
+				enterOuterAlt(_localctx, 7);
+				{
+				setState(612);
+				match(TRANSIENT);
+				}
+				break;
+			case VOLATILE:
+				enterOuterAlt(_localctx, 8);
+				{
+				setState(613);
+				match(VOLATILE);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class VariableDeclaratorListContext extends ParserRuleContext {
+		public List<VariableDeclaratorContext> variableDeclarator() {
+			return getRuleContexts(VariableDeclaratorContext.class);
+		}
+		public VariableDeclaratorContext variableDeclarator(int i) {
+			return getRuleContext(VariableDeclaratorContext.class,i);
+		}
+		public VariableDeclaratorListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_variableDeclaratorList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterVariableDeclaratorList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitVariableDeclaratorList(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitVariableDeclaratorList(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final VariableDeclaratorListContext variableDeclaratorList() throws RecognitionException {
+		VariableDeclaratorListContext _localctx = new VariableDeclaratorListContext(_ctx, getState());
+		enterRule(_localctx, 96, RULE_variableDeclaratorList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(616);
+			variableDeclarator();
+			setState(621);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==COMMA) {
+				{
+				{
+				setState(617);
+				match(COMMA);
+				setState(618);
+				variableDeclarator();
+				}
+				}
+				setState(623);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class VariableDeclaratorContext extends ParserRuleContext {
+		public VariableDeclaratorIdContext variableDeclaratorId() {
+			return getRuleContext(VariableDeclaratorIdContext.class,0);
+		}
+		public VariableInitializerContext variableInitializer() {
+			return getRuleContext(VariableInitializerContext.class,0);
+		}
+		public VariableDeclaratorContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_variableDeclarator; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterVariableDeclarator(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitVariableDeclarator(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitVariableDeclarator(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final VariableDeclaratorContext variableDeclarator() throws RecognitionException {
+		VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState());
+		enterRule(_localctx, 98, RULE_variableDeclarator);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(624);
+			variableDeclaratorId();
+			setState(627);
+			_la = _input.LA(1);
+			if (_la==ASSIGN) {
+				{
+				setState(625);
+				match(ASSIGN);
+				setState(626);
+				variableInitializer();
+				}
+			}
+
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
 	public static class VariableDeclaratorIdContext extends ParserRuleContext {
 		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
 		public DimsContext dims() {
@@ -3281,22 +3606,27 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitVariableDeclaratorId(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitVariableDeclaratorId(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException {
 		VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState());
-		enterRule(_localctx, 98, RULE_variableDeclaratorId);
+		enterRule(_localctx, 100, RULE_variableDeclaratorId);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(623);
+			setState(629);
 			match(Identifier);
-			setState(625);
+			setState(631);
 			_la = _input.LA(1);
 			if (_la==LBRACK || _la==AT) {
 				{
-				setState(624);
+				setState(630);
 				dims();
 				}
 			}
@@ -3333,25 +3663,30 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitVariableInitializer(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitVariableInitializer(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final VariableInitializerContext variableInitializer() throws RecognitionException {
 		VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState());
-		enterRule(_localctx, 100, RULE_variableInitializer);
+		enterRule(_localctx, 102, RULE_variableInitializer);
 		try {
-			setState(629);
-			switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
+			setState(635);
+			switch ( getInterpreter().adaptivePredict(_input,56,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(627);
+				setState(633);
 				expression();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(628);
+				setState(634);
 				arrayInitializer();
 				}
 				break;
@@ -3387,25 +3722,30 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitUnannType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final UnannTypeContext unannType() throws RecognitionException {
 		UnannTypeContext _localctx = new UnannTypeContext(_ctx, getState());
-		enterRule(_localctx, 102, RULE_unannType);
+		enterRule(_localctx, 104, RULE_unannType);
 		try {
-			setState(633);
-			switch ( getInterpreter().adaptivePredict(_input,56,_ctx) ) {
+			setState(639);
+			switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(631);
+				setState(637);
 				unannPrimitiveType();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(632);
+				setState(638);
 				unannReferenceType();
 				}
 				break;
@@ -3438,13 +3778,18 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannPrimitiveType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitUnannPrimitiveType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final UnannPrimitiveTypeContext unannPrimitiveType() throws RecognitionException {
 		UnannPrimitiveTypeContext _localctx = new UnannPrimitiveTypeContext(_ctx, getState());
-		enterRule(_localctx, 104, RULE_unannPrimitiveType);
+		enterRule(_localctx, 106, RULE_unannPrimitiveType);
 		try {
-			setState(637);
+			setState(643);
 			switch (_input.LA(1)) {
 			case BYTE:
 			case CHAR:
@@ -3455,14 +3800,14 @@ public final UnannPrimitiveTypeContext unannPrimitiveType() throws RecognitionEx
 			case SHORT:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(635);
+				setState(641);
 				numericType();
 				}
 				break;
 			case BOOLEAN:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(636);
+				setState(642);
 				match(BOOLEAN);
 				}
 				break;
@@ -3503,32 +3848,37 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannReferenceType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitUnannReferenceType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final UnannReferenceTypeContext unannReferenceType() throws RecognitionException {
 		UnannReferenceTypeContext _localctx = new UnannReferenceTypeContext(_ctx, getState());
-		enterRule(_localctx, 106, RULE_unannReferenceType);
+		enterRule(_localctx, 108, RULE_unannReferenceType);
 		try {
-			setState(642);
-			switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) {
+			setState(648);
+			switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(639);
+				setState(645);
 				unannClassOrInterfaceType();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(640);
+				setState(646);
 				unannTypeVariable();
 				}
 				break;
 			case 3:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(641);
+				setState(647);
 				unannArrayType();
 				}
 				break;
@@ -3576,56 +3926,61 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannClassOrInterfaceType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitUnannClassOrInterfaceType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() throws RecognitionException {
 		UnannClassOrInterfaceTypeContext _localctx = new UnannClassOrInterfaceTypeContext(_ctx, getState());
-		enterRule(_localctx, 108, RULE_unannClassOrInterfaceType);
+		enterRule(_localctx, 110, RULE_unannClassOrInterfaceType);
 		try {
 			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(646);
-			switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
+			setState(652);
+			switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
 			case 1:
 				{
-				setState(644);
+				setState(650);
 				unannClassType_lfno_unannClassOrInterfaceType();
 				}
 				break;
 			case 2:
 				{
-				setState(645);
+				setState(651);
 				unannInterfaceType_lfno_unannClassOrInterfaceType();
 				}
 				break;
 			}
-			setState(652);
+			setState(658);
 			_errHandler.sync(this);
-			_alt = getInterpreter().adaptivePredict(_input,61,_ctx);
+			_alt = getInterpreter().adaptivePredict(_input,62,_ctx);
 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 				if ( _alt==1 ) {
 					{
-					setState(650);
-					switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
+					setState(656);
+					switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
 					case 1:
 						{
-						setState(648);
+						setState(654);
 						unannClassType_lf_unannClassOrInterfaceType();
 						}
 						break;
 					case 2:
 						{
-						setState(649);
+						setState(655);
 						unannInterfaceType_lf_unannClassOrInterfaceType();
 						}
 						break;
 					}
 					} 
 				}
-				setState(654);
+				setState(660);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,61,_ctx);
+				_alt = getInterpreter().adaptivePredict(_input,62,_ctx);
 			}
 			}
 		}
@@ -3663,38 +4018,43 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannClassType_lf_unannClassOrInterfaceType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitUnannClassType_lf_unannClassOrInterfaceType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() throws RecognitionException {
 		UnannClassType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lf_unannClassOrInterfaceTypeContext(_ctx, getState());
-		enterRule(_localctx, 110, RULE_unannClassType_lf_unannClassOrInterfaceType);
+		enterRule(_localctx, 112, RULE_unannClassType_lf_unannClassOrInterfaceType);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(655);
+			setState(661);
 			match(DOT);
-			setState(659);
+			setState(665);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==AT) {
 				{
 				{
-				setState(656);
+				setState(662);
 				annotation();
 				}
 				}
-				setState(661);
+				setState(667);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(662);
+			setState(668);
 			match(Identifier);
-			setState(664);
-			switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) {
+			setState(670);
+			switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
 			case 1:
 				{
-				setState(663);
+				setState(669);
 				typeArguments();
 				}
 				break;
@@ -3729,21 +4089,26 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannClassType_lfno_unannClassOrInterfaceType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitUnannClassType_lfno_unannClassOrInterfaceType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() throws RecognitionException {
 		UnannClassType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState());
-		enterRule(_localctx, 112, RULE_unannClassType_lfno_unannClassOrInterfaceType);
+		enterRule(_localctx, 114, RULE_unannClassType_lfno_unannClassOrInterfaceType);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(666);
+			setState(672);
 			match(Identifier);
-			setState(668);
-			switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
+			setState(674);
+			switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
 			case 1:
 				{
-				setState(667);
+				setState(673);
 				typeArguments();
 				}
 				break;
@@ -3777,15 +4142,20 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannInterfaceType_lf_unannClassOrInterfaceType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitUnannInterfaceType_lf_unannClassOrInterfaceType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType() throws RecognitionException {
 		UnannInterfaceType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(_ctx, getState());
-		enterRule(_localctx, 114, RULE_unannInterfaceType_lf_unannClassOrInterfaceType);
+		enterRule(_localctx, 116, RULE_unannInterfaceType_lf_unannClassOrInterfaceType);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(670);
+			setState(676);
 			unannClassType_lf_unannClassOrInterfaceType();
 			}
 		}
@@ -3816,15 +4186,20 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannInterfaceType_lfno_unannClassOrInterfaceType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitUnannInterfaceType_lfno_unannClassOrInterfaceType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() throws RecognitionException {
 		UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState());
-		enterRule(_localctx, 116, RULE_unannInterfaceType_lfno_unannClassOrInterfaceType);
+		enterRule(_localctx, 118, RULE_unannInterfaceType_lfno_unannClassOrInterfaceType);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(672);
+			setState(678);
 			unannClassType_lfno_unannClassOrInterfaceType();
 			}
 		}
@@ -3853,15 +4228,20 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannTypeVariable(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitUnannTypeVariable(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final UnannTypeVariableContext unannTypeVariable() throws RecognitionException {
 		UnannTypeVariableContext _localctx = new UnannTypeVariableContext(_ctx, getState());
-		enterRule(_localctx, 118, RULE_unannTypeVariable);
+		enterRule(_localctx, 120, RULE_unannTypeVariable);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(674);
+			setState(680);
 			match(Identifier);
 			}
 		}
@@ -3901,38 +4281,43 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitUnannArrayType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitUnannArrayType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final UnannArrayTypeContext unannArrayType() throws RecognitionException {
 		UnannArrayTypeContext _localctx = new UnannArrayTypeContext(_ctx, getState());
-		enterRule(_localctx, 120, RULE_unannArrayType);
+		enterRule(_localctx, 122, RULE_unannArrayType);
 		try {
-			setState(685);
-			switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
+			setState(691);
+			switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(676);
+				setState(682);
 				unannPrimitiveType();
-				setState(677);
+				setState(683);
 				dims();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(679);
+				setState(685);
 				unannClassOrInterfaceType();
-				setState(680);
+				setState(686);
 				dims();
 				}
 				break;
 			case 3:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(682);
+				setState(688);
 				unannTypeVariable();
-				setState(683);
+				setState(689);
 				dims();
 				}
 				break;
@@ -3974,32 +4359,37 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitMethodDeclaration(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitMethodDeclaration(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final MethodDeclarationContext methodDeclaration() throws RecognitionException {
 		MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 122, RULE_methodDeclaration);
+		enterRule(_localctx, 124, RULE_methodDeclaration);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(690);
+			setState(696);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED))) != 0) || _la==AT) {
 				{
 				{
-				setState(687);
+				setState(693);
 				methodModifier();
 				}
 				}
-				setState(692);
+				setState(698);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(693);
+			setState(699);
 			methodHeader();
-			setState(694);
+			setState(700);
 			methodBody();
 			}
 		}
@@ -4030,81 +4420,86 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitMethodModifier(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitMethodModifier(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final MethodModifierContext methodModifier() throws RecognitionException {
 		MethodModifierContext _localctx = new MethodModifierContext(_ctx, getState());
-		enterRule(_localctx, 124, RULE_methodModifier);
+		enterRule(_localctx, 126, RULE_methodModifier);
 		try {
-			setState(706);
+			setState(712);
 			switch (_input.LA(1)) {
 			case AT:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(696);
+				setState(702);
 				annotation();
 				}
 				break;
 			case PUBLIC:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(697);
+				setState(703);
 				match(PUBLIC);
 				}
 				break;
 			case PROTECTED:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(698);
+				setState(704);
 				match(PROTECTED);
 				}
 				break;
 			case PRIVATE:
 				enterOuterAlt(_localctx, 4);
 				{
-				setState(699);
+				setState(705);
 				match(PRIVATE);
 				}
 				break;
 			case ABSTRACT:
 				enterOuterAlt(_localctx, 5);
 				{
-				setState(700);
+				setState(706);
 				match(ABSTRACT);
 				}
 				break;
 			case STATIC:
 				enterOuterAlt(_localctx, 6);
 				{
-				setState(701);
+				setState(707);
 				match(STATIC);
 				}
 				break;
 			case FINAL:
 				enterOuterAlt(_localctx, 7);
 				{
-				setState(702);
+				setState(708);
 				match(FINAL);
 				}
 				break;
 			case SYNCHRONIZED:
 				enterOuterAlt(_localctx, 8);
 				{
-				setState(703);
+				setState(709);
 				match(SYNCHRONIZED);
 				}
 				break;
 			case NATIVE:
 				enterOuterAlt(_localctx, 9);
 				{
-				setState(704);
+				setState(710);
 				match(NATIVE);
 				}
 				break;
 			case STRICTFP:
 				enterOuterAlt(_localctx, 10);
 				{
-				setState(705);
+				setState(711);
 				match(STRICTFP);
 				}
 				break;
@@ -4154,14 +4549,19 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitMethodHeader(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitMethodHeader(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final MethodHeaderContext methodHeader() throws RecognitionException {
 		MethodHeaderContext _localctx = new MethodHeaderContext(_ctx, getState());
-		enterRule(_localctx, 126, RULE_methodHeader);
+		enterRule(_localctx, 128, RULE_methodHeader);
 		int _la;
 		try {
-			setState(725);
+			setState(731);
 			switch (_input.LA(1)) {
 			case BOOLEAN:
 			case BYTE:
@@ -4175,15 +4575,15 @@ public final MethodHeaderContext methodHeader() throws RecognitionException {
 			case Identifier:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(708);
+				setState(714);
 				result();
-				setState(709);
+				setState(715);
 				methodDeclarator();
-				setState(711);
+				setState(717);
 				_la = _input.LA(1);
 				if (_la==THROWS) {
 					{
-					setState(710);
+					setState(716);
 					throws_();
 					}
 				}
@@ -4193,31 +4593,31 @@ public final MethodHeaderContext methodHeader() throws RecognitionException {
 			case LT:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(713);
+				setState(719);
 				typeParameters();
-				setState(717);
+				setState(723);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 				while (_la==AT) {
 					{
 					{
-					setState(714);
+					setState(720);
 					annotation();
 					}
 					}
-					setState(719);
+					setState(725);
 					_errHandler.sync(this);
 					_la = _input.LA(1);
 				}
-				setState(720);
+				setState(726);
 				result();
-				setState(721);
+				setState(727);
 				methodDeclarator();
-				setState(723);
+				setState(729);
 				_la = _input.LA(1);
 				if (_la==THROWS) {
 					{
-					setState(722);
+					setState(728);
 					throws_();
 					}
 				}
@@ -4255,13 +4655,18 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitResult(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitResult(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ResultContext result() throws RecognitionException {
 		ResultContext _localctx = new ResultContext(_ctx, getState());
-		enterRule(_localctx, 128, RULE_result);
+		enterRule(_localctx, 130, RULE_result);
 		try {
-			setState(729);
+			setState(735);
 			switch (_input.LA(1)) {
 			case BOOLEAN:
 			case BYTE:
@@ -4274,14 +4679,14 @@ public final ResultContext result() throws RecognitionException {
 			case Identifier:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(727);
+				setState(733);
 				unannType();
 				}
 				break;
 			case VOID:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(728);
+				setState(734);
 				match(VOID);
 				}
 				break;
@@ -4301,17 +4706,6 @@ public final ResultContext result() throws RecognitionException {
 	}
 
 	public static class MethodDeclaratorContext extends ParserRuleContext {
-		public MethodDeclaratorContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_methodDeclarator; }
-	 
-		public MethodDeclaratorContext() { }
-		public void copyFrom(MethodDeclaratorContext ctx) {
-			super.copyFrom(ctx);
-		}
-	}
-	public static class MethodNameContext extends MethodDeclaratorContext {
 		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
 		public FormalParameterListContext formalParameterList() {
 			return getRuleContext(FormalParameterListContext.class,0);
@@ -4319,45 +4713,52 @@ public FormalParameterListContext formalParameterList() {
 		public DimsContext dims() {
 			return getRuleContext(DimsContext.class,0);
 		}
-		public MethodNameContext(MethodDeclaratorContext ctx) { copyFrom(ctx); }
+		public MethodDeclaratorContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_methodDeclarator; }
 		@Override
 		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterMethodName(this);
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterMethodDeclarator(this);
 		}
 		@Override
 		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitMethodName(this);
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitMethodDeclarator(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitMethodDeclarator(this);
+			else return visitor.visitChildren(this);
 		}
 	}
 
 	public final MethodDeclaratorContext methodDeclarator() throws RecognitionException {
 		MethodDeclaratorContext _localctx = new MethodDeclaratorContext(_ctx, getState());
-		enterRule(_localctx, 130, RULE_methodDeclarator);
+		enterRule(_localctx, 132, RULE_methodDeclarator);
 		int _la;
 		try {
-			_localctx = new MethodNameContext(_localctx);
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(731);
+			setState(737);
 			match(Identifier);
-			setState(732);
+			setState(738);
 			match(LPAREN);
-			setState(734);
+			setState(740);
 			_la = _input.LA(1);
 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==Identifier || _la==AT) {
 				{
-				setState(733);
+				setState(739);
 				formalParameterList();
 				}
 			}
 
-			setState(736);
+			setState(742);
 			match(RPAREN);
-			setState(738);
+			setState(744);
 			_la = _input.LA(1);
 			if (_la==LBRACK || _la==AT) {
 				{
-				setState(737);
+				setState(743);
 				dims();
 				}
 			}
@@ -4394,29 +4795,34 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitFormalParameterList(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitFormalParameterList(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final FormalParameterListContext formalParameterList() throws RecognitionException {
 		FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState());
-		enterRule(_localctx, 132, RULE_formalParameterList);
+		enterRule(_localctx, 134, RULE_formalParameterList);
 		try {
-			setState(745);
-			switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
+			setState(751);
+			switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(740);
+				setState(746);
 				formalParameters();
-				setState(741);
+				setState(747);
 				match(COMMA);
-				setState(742);
+				setState(748);
 				lastFormalParameter();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(744);
+				setState(750);
 				lastFormalParameter();
 				}
 				break;
@@ -4455,62 +4861,67 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitFormalParameters(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitFormalParameters(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final FormalParametersContext formalParameters() throws RecognitionException {
 		FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState());
-		enterRule(_localctx, 134, RULE_formalParameters);
+		enterRule(_localctx, 136, RULE_formalParameters);
 		try {
 			int _alt;
-			setState(763);
-			switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) {
+			setState(769);
+			switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(747);
+				setState(753);
 				formalParameter();
-				setState(752);
+				setState(758);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,76,_ctx);
+				_alt = getInterpreter().adaptivePredict(_input,77,_ctx);
 				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 					if ( _alt==1 ) {
 						{
 						{
-						setState(748);
+						setState(754);
 						match(COMMA);
-						setState(749);
+						setState(755);
 						formalParameter();
 						}
 						} 
 					}
-					setState(754);
+					setState(760);
 					_errHandler.sync(this);
-					_alt = getInterpreter().adaptivePredict(_input,76,_ctx);
+					_alt = getInterpreter().adaptivePredict(_input,77,_ctx);
 				}
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(755);
+				setState(761);
 				receiverParameter();
-				setState(760);
+				setState(766);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,77,_ctx);
+				_alt = getInterpreter().adaptivePredict(_input,78,_ctx);
 				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 					if ( _alt==1 ) {
 						{
 						{
-						setState(756);
+						setState(762);
 						match(COMMA);
-						setState(757);
+						setState(763);
 						formalParameter();
 						}
 						} 
 					}
-					setState(762);
+					setState(768);
 					_errHandler.sync(this);
-					_alt = getInterpreter().adaptivePredict(_input,77,_ctx);
+					_alt = getInterpreter().adaptivePredict(_input,78,_ctx);
 				}
 				}
 				break;
@@ -4552,32 +4963,37 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitFormalParameter(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitFormalParameter(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final FormalParameterContext formalParameter() throws RecognitionException {
 		FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState());
-		enterRule(_localctx, 136, RULE_formalParameter);
+		enterRule(_localctx, 138, RULE_formalParameter);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(768);
+			setState(774);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==FINAL || _la==AT) {
 				{
 				{
-				setState(765);
+				setState(771);
 				variableModifier();
 				}
 				}
-				setState(770);
+				setState(776);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(771);
+			setState(777);
 			unannType();
-			setState(772);
+			setState(778);
 			variableDeclaratorId();
 			}
 		}
@@ -4608,25 +5024,30 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitVariableModifier(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitVariableModifier(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final VariableModifierContext variableModifier() throws RecognitionException {
 		VariableModifierContext _localctx = new VariableModifierContext(_ctx, getState());
-		enterRule(_localctx, 138, RULE_variableModifier);
+		enterRule(_localctx, 140, RULE_variableModifier);
 		try {
-			setState(776);
+			setState(782);
 			switch (_input.LA(1)) {
 			case AT:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(774);
+				setState(780);
 				annotation();
 				}
 				break;
 			case FINAL:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(775);
+				setState(781);
 				match(FINAL);
 				}
 				break;
@@ -4679,58 +5100,63 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitLastFormalParameter(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitLastFormalParameter(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final LastFormalParameterContext lastFormalParameter() throws RecognitionException {
 		LastFormalParameterContext _localctx = new LastFormalParameterContext(_ctx, getState());
-		enterRule(_localctx, 140, RULE_lastFormalParameter);
+		enterRule(_localctx, 142, RULE_lastFormalParameter);
 		int _la;
 		try {
-			setState(795);
-			switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) {
+			setState(801);
+			switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(781);
+				setState(787);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 				while (_la==FINAL || _la==AT) {
 					{
 					{
-					setState(778);
+					setState(784);
 					variableModifier();
 					}
 					}
-					setState(783);
+					setState(789);
 					_errHandler.sync(this);
 					_la = _input.LA(1);
 				}
-				setState(784);
+				setState(790);
 				unannType();
-				setState(788);
+				setState(794);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 				while (_la==AT) {
 					{
 					{
-					setState(785);
+					setState(791);
 					annotation();
 					}
 					}
-					setState(790);
+					setState(796);
 					_errHandler.sync(this);
 					_la = _input.LA(1);
 				}
-				setState(791);
+				setState(797);
 				match(ELLIPSIS);
-				setState(792);
+				setState(798);
 				variableDeclaratorId();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(794);
+				setState(800);
 				formalParameter();
 				}
 				break;
@@ -4770,43 +5196,48 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitReceiverParameter(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitReceiverParameter(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ReceiverParameterContext receiverParameter() throws RecognitionException {
 		ReceiverParameterContext _localctx = new ReceiverParameterContext(_ctx, getState());
-		enterRule(_localctx, 142, RULE_receiverParameter);
+		enterRule(_localctx, 144, RULE_receiverParameter);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(800);
+			setState(806);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==AT) {
 				{
 				{
-				setState(797);
+				setState(803);
 				annotation();
 				}
 				}
-				setState(802);
+				setState(808);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(803);
+			setState(809);
 			unannType();
-			setState(806);
+			setState(812);
 			_la = _input.LA(1);
 			if (_la==Identifier) {
 				{
-				setState(804);
+				setState(810);
 				match(Identifier);
-				setState(805);
+				setState(811);
 				match(DOT);
 				}
 			}
 
-			setState(808);
+			setState(814);
 			match(THIS);
 			}
 		}
@@ -4837,17 +5268,22 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitThrows_(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitThrows_(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final Throws_Context throws_() throws RecognitionException {
 		Throws_Context _localctx = new Throws_Context(_ctx, getState());
-		enterRule(_localctx, 144, RULE_throws_);
+		enterRule(_localctx, 146, RULE_throws_);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(810);
+			setState(816);
 			match(THROWS);
-			setState(811);
+			setState(817);
 			exceptionTypeList();
 			}
 		}
@@ -4881,30 +5317,35 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitExceptionTypeList(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitExceptionTypeList(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ExceptionTypeListContext exceptionTypeList() throws RecognitionException {
 		ExceptionTypeListContext _localctx = new ExceptionTypeListContext(_ctx, getState());
-		enterRule(_localctx, 146, RULE_exceptionTypeList);
+		enterRule(_localctx, 148, RULE_exceptionTypeList);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(813);
+			setState(819);
 			exceptionType();
-			setState(818);
+			setState(824);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==COMMA) {
 				{
 				{
-				setState(814);
+				setState(820);
 				match(COMMA);
-				setState(815);
+				setState(821);
 				exceptionType();
 				}
 				}
-				setState(820);
+				setState(826);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
@@ -4940,25 +5381,30 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitExceptionType(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitExceptionType(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ExceptionTypeContext exceptionType() throws RecognitionException {
 		ExceptionTypeContext _localctx = new ExceptionTypeContext(_ctx, getState());
-		enterRule(_localctx, 148, RULE_exceptionType);
+		enterRule(_localctx, 150, RULE_exceptionType);
 		try {
-			setState(823);
-			switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
+			setState(829);
+			switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(821);
+				setState(827);
 				classType();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(822);
+				setState(828);
 				typeVariable();
 				}
 				break;
@@ -4991,25 +5437,30 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitMethodBody(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitMethodBody(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final MethodBodyContext methodBody() throws RecognitionException {
 		MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState());
-		enterRule(_localctx, 150, RULE_methodBody);
+		enterRule(_localctx, 152, RULE_methodBody);
 		try {
-			setState(827);
+			setState(833);
 			switch (_input.LA(1)) {
 			case LBRACE:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(825);
+				setState(831);
 				block();
 				}
 				break;
 			case SEMI:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(826);
+				setState(832);
 				match(SEMI);
 				}
 				break;
@@ -5044,15 +5495,20 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInstanceInitializer(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitInstanceInitializer(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final InstanceInitializerContext instanceInitializer() throws RecognitionException {
 		InstanceInitializerContext _localctx = new InstanceInitializerContext(_ctx, getState());
-		enterRule(_localctx, 152, RULE_instanceInitializer);
+		enterRule(_localctx, 154, RULE_instanceInitializer);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(829);
+			setState(835);
 			block();
 			}
 		}
@@ -5083,17 +5539,22 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitStaticInitializer(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitStaticInitializer(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final StaticInitializerContext staticInitializer() throws RecognitionException {
 		StaticInitializerContext _localctx = new StaticInitializerContext(_ctx, getState());
-		enterRule(_localctx, 154, RULE_staticInitializer);
+		enterRule(_localctx, 156, RULE_staticInitializer);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(831);
+			setState(837);
 			match(STATIC);
-			setState(832);
+			setState(838);
 			block();
 			}
 		}
@@ -5136,41 +5597,46 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConstructorDeclaration(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitConstructorDeclaration(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException {
 		ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 156, RULE_constructorDeclaration);
+		enterRule(_localctx, 158, RULE_constructorDeclaration);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(837);
+			setState(843);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC))) != 0) || _la==AT) {
 				{
 				{
-				setState(834);
+				setState(840);
 				constructorModifier();
 				}
 				}
-				setState(839);
+				setState(845);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(840);
+			setState(846);
 			constructorDeclarator();
-			setState(842);
+			setState(848);
 			_la = _input.LA(1);
 			if (_la==THROWS) {
 				{
-				setState(841);
+				setState(847);
 				throws_();
 				}
 			}
 
-			setState(844);
+			setState(850);
 			constructorBody();
 			}
 		}
@@ -5201,39 +5667,44 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConstructorModifier(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitConstructorModifier(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ConstructorModifierContext constructorModifier() throws RecognitionException {
 		ConstructorModifierContext _localctx = new ConstructorModifierContext(_ctx, getState());
-		enterRule(_localctx, 158, RULE_constructorModifier);
+		enterRule(_localctx, 160, RULE_constructorModifier);
 		try {
-			setState(850);
+			setState(856);
 			switch (_input.LA(1)) {
 			case AT:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(846);
+				setState(852);
 				annotation();
 				}
 				break;
 			case PUBLIC:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(847);
+				setState(853);
 				match(PUBLIC);
 				}
 				break;
 			case PROTECTED:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(848);
+				setState(854);
 				match(PROTECTED);
 				}
 				break;
 			case PRIVATE:
 				enterOuterAlt(_localctx, 4);
 				{
-				setState(849);
+				setState(855);
 				match(PRIVATE);
 				}
 				break;
@@ -5274,38 +5745,43 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConstructorDeclarator(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitConstructorDeclarator(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ConstructorDeclaratorContext constructorDeclarator() throws RecognitionException {
 		ConstructorDeclaratorContext _localctx = new ConstructorDeclaratorContext(_ctx, getState());
-		enterRule(_localctx, 160, RULE_constructorDeclarator);
+		enterRule(_localctx, 162, RULE_constructorDeclarator);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(853);
+			setState(859);
 			_la = _input.LA(1);
 			if (_la==LT) {
 				{
-				setState(852);
+				setState(858);
 				typeParameters();
 				}
 			}
 
-			setState(855);
+			setState(861);
 			simpleTypeName();
-			setState(856);
+			setState(862);
 			match(LPAREN);
-			setState(858);
+			setState(864);
 			_la = _input.LA(1);
 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==Identifier || _la==AT) {
 				{
-				setState(857);
+				setState(863);
 				formalParameterList();
 				}
 			}
 
-			setState(860);
+			setState(866);
 			match(RPAREN);
 			}
 		}
@@ -5342,16 +5818,21 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConstructorName(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitConstructorName(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final SimpleTypeNameContext simpleTypeName() throws RecognitionException {
 		SimpleTypeNameContext _localctx = new SimpleTypeNameContext(_ctx, getState());
-		enterRule(_localctx, 162, RULE_simpleTypeName);
+		enterRule(_localctx, 164, RULE_simpleTypeName);
 		try {
 			_localctx = new ConstructorNameContext(_localctx);
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(862);
+			setState(868);
 			match(Identifier);
 			}
 		}
@@ -5367,9 +5848,6 @@ public final SimpleTypeNameContext simpleTypeName() throws RecognitionException
 	}
 
 	public static class ConstructorBodyContext extends ParserRuleContext {
-		public ExplicitConstructorInvocationContext explicitConstructorInvocation() {
-			return getRuleContext(ExplicitConstructorInvocationContext.class,0);
-		}
 		public BlockStatementsContext blockStatements() {
 			return getRuleContext(BlockStatementsContext.class,0);
 		}
@@ -5380,220 +5858,30 @@ public ConstructorBodyContext(ParserRuleContext parent, int invokingState) {
 		@Override
 		public void enterRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterConstructorBody(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConstructorBody(this);
-		}
-	}
-
-	public final ConstructorBodyContext constructorBody() throws RecognitionException {
-		ConstructorBodyContext _localctx = new ConstructorBodyContext(_ctx, getState());
-		enterRule(_localctx, 164, RULE_constructorBody);
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(864);
-			match(LBRACE);
-			setState(866);
-			switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
-			case 1:
-				{
-				setState(865);
-				explicitConstructorInvocation();
-				}
-				break;
-			}
-			setState(869);
-			switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
-			case 1:
-				{
-				setState(868);
-				blockStatements();
-				}
-				break;
-			}
-			setState(871);
-			match(RBRACE);
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class ExplicitConstructorInvocationContext extends ParserRuleContext {
-		public TypeArgumentsContext typeArguments() {
-			return getRuleContext(TypeArgumentsContext.class,0);
-		}
-		public ArgumentListContext argumentList() {
-			return getRuleContext(ArgumentListContext.class,0);
-		}
-		public ExpressionNameContext expressionName() {
-			return getRuleContext(ExpressionNameContext.class,0);
-		}
-		public PrimaryContext primary() {
-			return getRuleContext(PrimaryContext.class,0);
-		}
-		public ExplicitConstructorInvocationContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_explicitConstructorInvocation; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterExplicitConstructorInvocation(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitExplicitConstructorInvocation(this);
-		}
-	}
-
-	public final ExplicitConstructorInvocationContext explicitConstructorInvocation() throws RecognitionException {
-		ExplicitConstructorInvocationContext _localctx = new ExplicitConstructorInvocationContext(_ctx, getState());
-		enterRule(_localctx, 166, RULE_explicitConstructorInvocation);
-		int _la;
-		try {
-			setState(919);
-			switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) {
-			case 1:
-				enterOuterAlt(_localctx, 1);
-				{
-				setState(874);
-				_la = _input.LA(1);
-				if (_la==LT) {
-					{
-					setState(873);
-					typeArguments();
-					}
-				}
-
-				setState(876);
-				match(THIS);
-				setState(877);
-				match(LPAREN);
-				setState(879);
-				switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
-				case 1:
-					{
-					setState(878);
-					argumentList();
-					}
-					break;
-				}
-				setState(881);
-				match(RPAREN);
-				setState(882);
-				match(SEMI);
-				}
-				break;
-			case 2:
-				enterOuterAlt(_localctx, 2);
-				{
-				setState(884);
-				_la = _input.LA(1);
-				if (_la==LT) {
-					{
-					setState(883);
-					typeArguments();
-					}
-				}
-
-				setState(886);
-				match(SUPER);
-				setState(887);
-				match(LPAREN);
-				setState(889);
-				switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) {
-				case 1:
-					{
-					setState(888);
-					argumentList();
-					}
-					break;
-				}
-				setState(891);
-				match(RPAREN);
-				setState(892);
-				match(SEMI);
-				}
-				break;
-			case 3:
-				enterOuterAlt(_localctx, 3);
-				{
-				setState(893);
-				expressionName();
-				setState(894);
-				match(DOT);
-				setState(896);
-				_la = _input.LA(1);
-				if (_la==LT) {
-					{
-					setState(895);
-					typeArguments();
-					}
-				}
-
-				setState(898);
-				match(SUPER);
-				setState(899);
-				match(LPAREN);
-				setState(901);
-				switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) {
-				case 1:
-					{
-					setState(900);
-					argumentList();
-					}
-					break;
-				}
-				setState(903);
-				match(RPAREN);
-				setState(904);
-				match(SEMI);
-				}
-				break;
-			case 4:
-				enterOuterAlt(_localctx, 4);
-				{
-				setState(906);
-				primary();
-				setState(907);
-				match(DOT);
-				setState(909);
-				_la = _input.LA(1);
-				if (_la==LT) {
-					{
-					setState(908);
-					typeArguments();
-					}
-				}
-
-				setState(911);
-				match(SUPER);
-				setState(912);
-				match(LPAREN);
-				setState(914);
-				switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
-				case 1:
-					{
-					setState(913);
-					argumentList();
-					}
-					break;
-				}
-				setState(916);
-				match(RPAREN);
-				setState(917);
-				match(SEMI);
-				}
-				break;
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConstructorBody(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitConstructorBody(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final ConstructorBodyContext constructorBody() throws RecognitionException {
+		ConstructorBodyContext _localctx = new ConstructorBodyContext(_ctx, getState());
+		enterRule(_localctx, 166, RULE_constructorBody);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(870);
+			match(LBRACE);
+			setState(871);
+			blockStatements();
+			setState(872);
+			match(RBRACE);
 			}
 		}
 		catch (RecognitionException re) {
@@ -5641,6 +5929,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitEnumName(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitEnumName(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final EnumDeclarationContext enumDeclaration() throws RecognitionException {
@@ -5651,34 +5944,34 @@ public final EnumDeclarationContext enumDeclaration() throws RecognitionExceptio
 			_localctx = new EnumNameContext(_localctx);
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(924);
+			setState(877);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
 				{
 				{
-				setState(921);
+				setState(874);
 				classModifier();
 				}
 				}
-				setState(926);
+				setState(879);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(927);
+			setState(880);
 			match(ENUM);
-			setState(928);
+			setState(881);
 			match(Identifier);
-			setState(930);
+			setState(883);
 			_la = _input.LA(1);
 			if (_la==IMPLEMENTS) {
 				{
-				setState(929);
+				setState(882);
 				superinterfaces();
 				}
 			}
 
-			setState(932);
+			setState(885);
 			enumBody();
 			}
 		}
@@ -5712,6 +6005,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitEnumBody(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitEnumBody(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final EnumBodyContext enumBody() throws RecognitionException {
@@ -5721,36 +6019,36 @@ public final EnumBodyContext enumBody() throws RecognitionException {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(934);
+			setState(887);
 			match(LBRACE);
-			setState(936);
+			setState(889);
 			_la = _input.LA(1);
 			if (_la==Identifier || _la==AT) {
 				{
-				setState(935);
+				setState(888);
 				enumConstantList();
 				}
 			}
 
-			setState(939);
+			setState(892);
 			_la = _input.LA(1);
 			if (_la==COMMA) {
 				{
-				setState(938);
+				setState(891);
 				match(COMMA);
 				}
 			}
 
-			setState(942);
+			setState(895);
 			_la = _input.LA(1);
 			if (_la==SEMI) {
 				{
-				setState(941);
+				setState(894);
 				enumBodyDeclarations();
 				}
 			}
 
-			setState(944);
+			setState(897);
 			match(RBRACE);
 			}
 		}
@@ -5784,6 +6082,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitEnumConstantList(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitEnumConstantList(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final EnumConstantListContext enumConstantList() throws RecognitionException {
@@ -5793,25 +6096,25 @@ public final EnumConstantListContext enumConstantList() throws RecognitionExcept
 			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(946);
+			setState(899);
 			enumConstant();
-			setState(951);
+			setState(904);
 			_errHandler.sync(this);
-			_alt = getInterpreter().adaptivePredict(_input,110,_ctx);
+			_alt = getInterpreter().adaptivePredict(_input,100,_ctx);
 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 				if ( _alt==1 ) {
 					{
 					{
-					setState(947);
+					setState(900);
 					match(COMMA);
-					setState(948);
+					setState(901);
 					enumConstant();
 					}
 					} 
 				}
-				setState(953);
+				setState(906);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,110,_ctx);
+				_alt = getInterpreter().adaptivePredict(_input,100,_ctx);
 			}
 			}
 		}
@@ -5852,6 +6155,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitEnumConstant(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitEnumConstant(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final EnumConstantContext enumConstant() throws RecognitionException {
@@ -5861,47 +6169,47 @@ public final EnumConstantContext enumConstant() throws RecognitionException {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(957);
+			setState(910);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==AT) {
 				{
 				{
-				setState(954);
+				setState(907);
 				enumConstantModifier();
 				}
 				}
-				setState(959);
+				setState(912);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(960);
+			setState(913);
 			match(Identifier);
-			setState(966);
+			setState(919);
 			_la = _input.LA(1);
 			if (_la==LPAREN) {
 				{
-				setState(961);
+				setState(914);
 				match(LPAREN);
-				setState(963);
-				switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) {
+				setState(916);
+				switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) {
 				case 1:
 					{
-					setState(962);
+					setState(915);
 					argumentList();
 					}
 					break;
 				}
-				setState(965);
+				setState(918);
 				match(RPAREN);
 				}
 			}
 
-			setState(969);
+			setState(922);
 			_la = _input.LA(1);
 			if (_la==LBRACE) {
 				{
-				setState(968);
+				setState(921);
 				classBody();
 				}
 			}
@@ -5935,6 +6243,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitEnumConstantModifier(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitEnumConstantModifier(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final EnumConstantModifierContext enumConstantModifier() throws RecognitionException {
@@ -5943,7 +6256,7 @@ public final EnumConstantModifierContext enumConstantModifier() throws Recogniti
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(971);
+			setState(924);
 			annotation();
 			}
 		}
@@ -5977,32 +6290,35 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitEnumBodyDeclarations(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitEnumBodyDeclarations(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException {
 		EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState());
 		enterRule(_localctx, 178, RULE_enumBodyDeclarations);
+		int _la;
 		try {
-			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(973);
+			setState(926);
 			match(SEMI);
-			setState(977);
+			setState(930);
 			_errHandler.sync(this);
-			_alt = getInterpreter().adaptivePredict(_input,115,_ctx);
-			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
-				if ( _alt==1 ) {
-					{
-					{
-					setState(974);
-					classBodyDeclaration();
-					}
-					} 
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE) | (1L << LBRACE) | (1L << SEMI))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - 68)) | (1L << (Identifier - 68)) | (1L << (AT - 68)))) != 0)) {
+				{
+				{
+				setState(927);
+				classBodyDeclaration();
+				}
 				}
-				setState(979);
+				setState(932);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,115,_ctx);
+				_la = _input.LA(1);
 			}
 			}
 		}
@@ -6036,6 +6352,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitArgumentList(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitArgumentList(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ArgumentListContext argumentList() throws RecognitionException {
@@ -6045,21 +6366,21 @@ public final ArgumentListContext argumentList() throws RecognitionException {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(980);
+			setState(933);
 			expression();
-			setState(985);
+			setState(938);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==COMMA) {
 				{
 				{
-				setState(981);
+				setState(934);
 				match(COMMA);
-				setState(982);
+				setState(935);
 				expression();
 				}
 				}
-				setState(987);
+				setState(940);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
@@ -6089,6 +6410,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitExpression(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitExpression(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ExpressionContext expression() throws RecognitionException {
@@ -6098,7 +6424,7 @@ public final ExpressionContext expression() throws RecognitionException {
 			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(989); 
+			setState(942); 
 			_errHandler.sync(this);
 			_alt = 1+1;
 			do {
@@ -6106,7 +6432,7 @@ public final ExpressionContext expression() throws RecognitionException {
 				case 1+1:
 					{
 					{
-					setState(988);
+					setState(941);
 					matchWildcard();
 					}
 					}
@@ -6114,9 +6440,9 @@ public final ExpressionContext expression() throws RecognitionException {
 				default:
 					throw new NoViableAltException(this);
 				}
-				setState(991); 
+				setState(944); 
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,117,_ctx);
+				_alt = getInterpreter().adaptivePredict(_input,107,_ctx);
 			} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
 			}
 		}
@@ -6144,6 +6470,11 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConditionalExpression(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitConditionalExpression(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ConditionalExpressionContext conditionalExpression() throws RecognitionException {
@@ -6153,62 +6484,7 @@ public final ConditionalExpressionContext conditionalExpression() throws Recogni
 			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(994); 
-			_errHandler.sync(this);
-			_alt = 1+1;
-			do {
-				switch (_alt) {
-				case 1+1:
-					{
-					{
-					setState(993);
-					matchWildcard();
-					}
-					}
-					break;
-				default:
-					throw new NoViableAltException(this);
-				}
-				setState(996); 
-				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,118,_ctx);
-			} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class PrimaryContext extends ParserRuleContext {
-		public PrimaryContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_primary; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterPrimary(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitPrimary(this);
-		}
-	}
-
-	public final PrimaryContext primary() throws RecognitionException {
-		PrimaryContext _localctx = new PrimaryContext(_ctx, getState());
-		enterRule(_localctx, 186, RULE_primary);
-		try {
-			int _alt;
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(999); 
+			setState(947); 
 			_errHandler.sync(this);
 			_alt = 1+1;
 			do {
@@ -6216,7 +6492,7 @@ public final PrimaryContext primary() throws RecognitionException {
 				case 1+1:
 					{
 					{
-					setState(998);
+					setState(946);
 					matchWildcard();
 					}
 					}
@@ -6224,9 +6500,9 @@ public final PrimaryContext primary() throws RecognitionException {
 				default:
 					throw new NoViableAltException(this);
 				}
-				setState(1001); 
+				setState(949); 
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,119,_ctx);
+				_alt = getInterpreter().adaptivePredict(_input,108,_ctx);
 			} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
 			}
 		}
@@ -6260,25 +6536,30 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceDeclaration(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitInterfaceDeclaration(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException {
 		InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 188, RULE_interfaceDeclaration);
+		enterRule(_localctx, 186, RULE_interfaceDeclaration);
 		try {
-			setState(1005);
-			switch ( getInterpreter().adaptivePredict(_input,120,_ctx) ) {
+			setState(953);
+			switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(1003);
+				setState(951);
 				normalInterfaceDeclaration();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(1004);
+				setState(952);
 				annotationTypeDeclaration();
 				}
 				break;
@@ -6332,53 +6613,58 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitIfaceName(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitIfaceName(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final NormalInterfaceDeclarationContext normalInterfaceDeclaration() throws RecognitionException {
 		NormalInterfaceDeclarationContext _localctx = new NormalInterfaceDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 190, RULE_normalInterfaceDeclaration);
+		enterRule(_localctx, 188, RULE_normalInterfaceDeclaration);
 		int _la;
 		try {
 			_localctx = new IfaceNameContext(_localctx);
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1010);
+			setState(958);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
 				{
 				{
-				setState(1007);
+				setState(955);
 				interfaceModifier();
 				}
 				}
-				setState(1012);
+				setState(960);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(1013);
+			setState(961);
 			match(INTERFACE);
-			setState(1014);
+			setState(962);
 			match(Identifier);
-			setState(1016);
+			setState(964);
 			_la = _input.LA(1);
 			if (_la==LT) {
 				{
-				setState(1015);
+				setState(963);
 				typeParameters();
 				}
 			}
 
-			setState(1019);
+			setState(967);
 			_la = _input.LA(1);
 			if (_la==EXTENDS) {
 				{
-				setState(1018);
+				setState(966);
 				extendsInterfaces();
 				}
 			}
 
-			setState(1021);
+			setState(969);
 			interfaceBody();
 			}
 		}
@@ -6409,60 +6695,65 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceModifier(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitInterfaceModifier(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final InterfaceModifierContext interfaceModifier() throws RecognitionException {
 		InterfaceModifierContext _localctx = new InterfaceModifierContext(_ctx, getState());
-		enterRule(_localctx, 192, RULE_interfaceModifier);
+		enterRule(_localctx, 190, RULE_interfaceModifier);
 		try {
-			setState(1030);
+			setState(978);
 			switch (_input.LA(1)) {
 			case AT:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(1023);
+				setState(971);
 				annotation();
 				}
 				break;
 			case PUBLIC:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(1024);
+				setState(972);
 				match(PUBLIC);
 				}
 				break;
 			case PROTECTED:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(1025);
+				setState(973);
 				match(PROTECTED);
 				}
 				break;
 			case PRIVATE:
 				enterOuterAlt(_localctx, 4);
 				{
-				setState(1026);
+				setState(974);
 				match(PRIVATE);
 				}
 				break;
 			case ABSTRACT:
 				enterOuterAlt(_localctx, 5);
 				{
-				setState(1027);
+				setState(975);
 				match(ABSTRACT);
 				}
 				break;
 			case STATIC:
 				enterOuterAlt(_localctx, 6);
 				{
-				setState(1028);
+				setState(976);
 				match(STATIC);
 				}
 				break;
 			case STRICTFP:
 				enterOuterAlt(_localctx, 7);
 				{
-				setState(1029);
+				setState(977);
 				match(STRICTFP);
 				}
 				break;
@@ -6497,17 +6788,22 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitExtendsInterfaces(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitExtendsInterfaces(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ExtendsInterfacesContext extendsInterfaces() throws RecognitionException {
 		ExtendsInterfacesContext _localctx = new ExtendsInterfacesContext(_ctx, getState());
-		enterRule(_localctx, 194, RULE_extendsInterfaces);
+		enterRule(_localctx, 192, RULE_extendsInterfaces);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1032);
+			setState(980);
 			match(EXTENDS);
-			setState(1033);
+			setState(981);
 			interfaceTypeList();
 			}
 		}
@@ -6541,32 +6837,37 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceBody(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitInterfaceBody(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final InterfaceBodyContext interfaceBody() throws RecognitionException {
 		InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState());
-		enterRule(_localctx, 196, RULE_interfaceBody);
+		enterRule(_localctx, 194, RULE_interfaceBody);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1035);
+			setState(983);
 			match(LBRACE);
-			setState(1039);
+			setState(987);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DEFAULT) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << VOID) | (1L << SEMI))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - 68)) | (1L << (Identifier - 68)) | (1L << (AT - 68)))) != 0)) {
 				{
 				{
-				setState(1036);
+				setState(984);
 				interfaceMemberDeclaration();
 				}
 				}
-				setState(1041);
+				setState(989);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(1042);
+			setState(990);
 			match(RBRACE);
 			}
 		}
@@ -6606,46 +6907,51 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceMemberDeclaration(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitInterfaceMemberDeclaration(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final InterfaceMemberDeclarationContext interfaceMemberDeclaration() throws RecognitionException {
 		InterfaceMemberDeclarationContext _localctx = new InterfaceMemberDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 198, RULE_interfaceMemberDeclaration);
+		enterRule(_localctx, 196, RULE_interfaceMemberDeclaration);
 		try {
-			setState(1049);
-			switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
+			setState(997);
+			switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(1044);
+				setState(992);
 				constantDeclaration();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(1045);
+				setState(993);
 				interfaceMethodDeclaration();
 				}
 				break;
 			case 3:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(1046);
+				setState(994);
 				classDeclaration();
 				}
 				break;
 			case 4:
 				enterOuterAlt(_localctx, 4);
 				{
-				setState(1047);
+				setState(995);
 				interfaceDeclaration();
 				}
 				break;
 			case 5:
 				enterOuterAlt(_localctx, 5);
 				{
-				setState(1048);
+				setState(996);
 				match(SEMI);
 				}
 				break;
@@ -6684,33 +6990,38 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConstantDeclaration(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitConstantDeclaration(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ConstantDeclarationContext constantDeclaration() throws RecognitionException {
 		ConstantDeclarationContext _localctx = new ConstantDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 200, RULE_constantDeclaration);
+		enterRule(_localctx, 198, RULE_constantDeclaration);
 		int _la;
 		try {
 			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1054);
+			setState(1002);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FINAL) | (1L << PUBLIC) | (1L << STATIC))) != 0) || _la==AT) {
 				{
 				{
-				setState(1051);
+				setState(999);
 				constantModifier();
 				}
 				}
-				setState(1056);
+				setState(1004);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(1057);
+			setState(1005);
 			unannType();
-			setState(1059); 
+			setState(1007); 
 			_errHandler.sync(this);
 			_alt = 1+1;
 			do {
@@ -6718,7 +7029,7 @@ public final ConstantDeclarationContext constantDeclaration() throws Recognition
 				case 1+1:
 					{
 					{
-					setState(1058);
+					setState(1006);
 					matchWildcard();
 					}
 					}
@@ -6726,11 +7037,11 @@ public final ConstantDeclarationContext constantDeclaration() throws Recognition
 				default:
 					throw new NoViableAltException(this);
 				}
-				setState(1061); 
+				setState(1009); 
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,128,_ctx);
+				_alt = getInterpreter().adaptivePredict(_input,117,_ctx);
 			} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
-			setState(1063);
+			setState(1011);
 			match(SEMI);
 			}
 		}
@@ -6761,39 +7072,44 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConstantModifier(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitConstantModifier(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ConstantModifierContext constantModifier() throws RecognitionException {
 		ConstantModifierContext _localctx = new ConstantModifierContext(_ctx, getState());
-		enterRule(_localctx, 202, RULE_constantModifier);
+		enterRule(_localctx, 200, RULE_constantModifier);
 		try {
-			setState(1069);
+			setState(1017);
 			switch (_input.LA(1)) {
 			case AT:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(1065);
+				setState(1013);
 				annotation();
 				}
 				break;
 			case PUBLIC:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(1066);
+				setState(1014);
 				match(PUBLIC);
 				}
 				break;
 			case STATIC:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(1067);
+				setState(1015);
 				match(STATIC);
 				}
 				break;
 			case FINAL:
 				enterOuterAlt(_localctx, 4);
 				{
-				setState(1068);
+				setState(1016);
 				match(FINAL);
 				}
 				break;
@@ -6837,32 +7153,37 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceMethodDeclaration(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitInterfaceMethodDeclaration(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException {
 		InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 204, RULE_interfaceMethodDeclaration);
+		enterRule(_localctx, 202, RULE_interfaceMethodDeclaration);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1074);
+			setState(1022);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << DEFAULT) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
 				{
 				{
-				setState(1071);
+				setState(1019);
 				interfaceMethodModifier();
 				}
 				}
-				setState(1076);
+				setState(1024);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(1077);
+			setState(1025);
 			methodHeader();
-			setState(1078);
+			setState(1026);
 			methodBody();
 			}
 		}
@@ -6893,53 +7214,58 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitInterfaceMethodModifier(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitInterfaceMethodModifier(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final InterfaceMethodModifierContext interfaceMethodModifier() throws RecognitionException {
 		InterfaceMethodModifierContext _localctx = new InterfaceMethodModifierContext(_ctx, getState());
-		enterRule(_localctx, 206, RULE_interfaceMethodModifier);
+		enterRule(_localctx, 204, RULE_interfaceMethodModifier);
 		try {
-			setState(1086);
+			setState(1034);
 			switch (_input.LA(1)) {
 			case AT:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(1080);
+				setState(1028);
 				annotation();
 				}
 				break;
 			case PUBLIC:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(1081);
+				setState(1029);
 				match(PUBLIC);
 				}
 				break;
 			case ABSTRACT:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(1082);
+				setState(1030);
 				match(ABSTRACT);
 				}
 				break;
 			case DEFAULT:
 				enterOuterAlt(_localctx, 4);
 				{
-				setState(1083);
+				setState(1031);
 				match(DEFAULT);
 				}
 				break;
 			case STATIC:
 				enterOuterAlt(_localctx, 5);
 				{
-				setState(1084);
+				setState(1032);
 				match(STATIC);
 				}
 				break;
 			case STRICTFP:
 				enterOuterAlt(_localctx, 6);
 				{
-				setState(1085);
+				setState(1033);
 				match(STRICTFP);
 				}
 				break;
@@ -6989,39 +7315,44 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitAnnoName(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitAnnoName(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException {
 		AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(_ctx, getState());
-		enterRule(_localctx, 208, RULE_annotationTypeDeclaration);
+		enterRule(_localctx, 206, RULE_annotationTypeDeclaration);
 		try {
 			int _alt;
 			_localctx = new AnnoNameContext(_localctx);
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1091);
+			setState(1039);
 			_errHandler.sync(this);
-			_alt = getInterpreter().adaptivePredict(_input,132,_ctx);
+			_alt = getInterpreter().adaptivePredict(_input,121,_ctx);
 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 				if ( _alt==1 ) {
 					{
 					{
-					setState(1088);
+					setState(1036);
 					interfaceModifier();
 					}
 					} 
 				}
-				setState(1093);
+				setState(1041);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,132,_ctx);
+				_alt = getInterpreter().adaptivePredict(_input,121,_ctx);
 			}
-			setState(1094);
+			setState(1042);
 			match(AT);
-			setState(1095);
+			setState(1043);
 			match(INTERFACE);
-			setState(1096);
+			setState(1044);
 			match(Identifier);
-			setState(1097);
+			setState(1045);
 			annotationTypeBody();
 			}
 		}
@@ -7049,18 +7380,23 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitAnnotationTypeBody(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitAnnotationTypeBody(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionException {
 		AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(_ctx, getState());
-		enterRule(_localctx, 210, RULE_annotationTypeBody);
+		enterRule(_localctx, 208, RULE_annotationTypeBody);
 		try {
 			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1099);
+			setState(1047);
 			match(LBRACE);
-			setState(1101); 
+			setState(1049); 
 			_errHandler.sync(this);
 			_alt = 1+1;
 			do {
@@ -7068,7 +7404,7 @@ public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionEx
 				case 1+1:
 					{
 					{
-					setState(1100);
+					setState(1048);
 					matchWildcard();
 					}
 					}
@@ -7076,11 +7412,11 @@ public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionEx
 				default:
 					throw new NoViableAltException(this);
 				}
-				setState(1103); 
+				setState(1051); 
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,133,_ctx);
+				_alt = getInterpreter().adaptivePredict(_input,122,_ctx);
 			} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
-			setState(1105);
+			setState(1053);
 			match(RBRACE);
 			}
 		}
@@ -7117,32 +7453,37 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitAnnotation(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitAnnotation(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final AnnotationContext annotation() throws RecognitionException {
 		AnnotationContext _localctx = new AnnotationContext(_ctx, getState());
-		enterRule(_localctx, 212, RULE_annotation);
+		enterRule(_localctx, 210, RULE_annotation);
 		try {
-			setState(1110);
-			switch ( getInterpreter().adaptivePredict(_input,134,_ctx) ) {
+			setState(1058);
+			switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(1107);
+				setState(1055);
 				normalAnnotation();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(1108);
+				setState(1056);
 				markerAnnotation();
 				}
 				break;
 			case 3:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(1109);
+				setState(1057);
 				singleElementAnnotation();
 				}
 				break;
@@ -7178,31 +7519,36 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitNormalAnnotation(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitNormalAnnotation(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final NormalAnnotationContext normalAnnotation() throws RecognitionException {
 		NormalAnnotationContext _localctx = new NormalAnnotationContext(_ctx, getState());
-		enterRule(_localctx, 214, RULE_normalAnnotation);
+		enterRule(_localctx, 212, RULE_normalAnnotation);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1112);
+			setState(1060);
 			match(AT);
-			setState(1113);
+			setState(1061);
 			typeName();
-			setState(1114);
+			setState(1062);
 			match(LPAREN);
-			setState(1116);
+			setState(1064);
 			_la = _input.LA(1);
 			if (_la==Identifier) {
 				{
-				setState(1115);
+				setState(1063);
 				elementValuePairList();
 				}
 			}
 
-			setState(1118);
+			setState(1066);
 			match(RPAREN);
 			}
 		}
@@ -7236,30 +7582,35 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitElementValuePairList(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitElementValuePairList(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ElementValuePairListContext elementValuePairList() throws RecognitionException {
 		ElementValuePairListContext _localctx = new ElementValuePairListContext(_ctx, getState());
-		enterRule(_localctx, 216, RULE_elementValuePairList);
+		enterRule(_localctx, 214, RULE_elementValuePairList);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1120);
+			setState(1068);
 			elementValuePair();
-			setState(1125);
+			setState(1073);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==COMMA) {
 				{
 				{
-				setState(1121);
+				setState(1069);
 				match(COMMA);
-				setState(1122);
+				setState(1070);
 				elementValuePair();
 				}
 				}
-				setState(1127);
+				setState(1075);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
@@ -7293,19 +7644,24 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitElementValuePair(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitElementValuePair(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ElementValuePairContext elementValuePair() throws RecognitionException {
 		ElementValuePairContext _localctx = new ElementValuePairContext(_ctx, getState());
-		enterRule(_localctx, 218, RULE_elementValuePair);
+		enterRule(_localctx, 216, RULE_elementValuePair);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1128);
+			setState(1076);
 			match(Identifier);
-			setState(1129);
+			setState(1077);
 			match(ASSIGN);
-			setState(1130);
+			setState(1078);
 			elementValue();
 			}
 		}
@@ -7342,32 +7698,37 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitElementValue(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitElementValue(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ElementValueContext elementValue() throws RecognitionException {
 		ElementValueContext _localctx = new ElementValueContext(_ctx, getState());
-		enterRule(_localctx, 220, RULE_elementValue);
+		enterRule(_localctx, 218, RULE_elementValue);
 		try {
-			setState(1135);
-			switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) {
+			setState(1083);
+			switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(1132);
+				setState(1080);
 				conditionalExpression();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(1133);
+				setState(1081);
 				elementValueArrayInitializer();
 				}
 				break;
 			case 3:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(1134);
+				setState(1082);
 				annotation();
 				}
 				break;
@@ -7400,36 +7761,41 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitElementValueArrayInitializer(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitElementValueArrayInitializer(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ElementValueArrayInitializerContext elementValueArrayInitializer() throws RecognitionException {
 		ElementValueArrayInitializerContext _localctx = new ElementValueArrayInitializerContext(_ctx, getState());
-		enterRule(_localctx, 222, RULE_elementValueArrayInitializer);
+		enterRule(_localctx, 220, RULE_elementValueArrayInitializer);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1137);
+			setState(1085);
 			match(LBRACE);
-			setState(1139);
-			switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) {
+			setState(1087);
+			switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
 			case 1:
 				{
-				setState(1138);
+				setState(1086);
 				elementValueList();
 				}
 				break;
 			}
-			setState(1142);
+			setState(1090);
 			_la = _input.LA(1);
 			if (_la==COMMA) {
 				{
-				setState(1141);
+				setState(1089);
 				match(COMMA);
 				}
 			}
 
-			setState(1144);
+			setState(1092);
 			match(RBRACE);
 			}
 		}
@@ -7463,34 +7829,39 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitElementValueList(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitElementValueList(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ElementValueListContext elementValueList() throws RecognitionException {
 		ElementValueListContext _localctx = new ElementValueListContext(_ctx, getState());
-		enterRule(_localctx, 224, RULE_elementValueList);
+		enterRule(_localctx, 222, RULE_elementValueList);
 		try {
 			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1146);
+			setState(1094);
 			elementValue();
-			setState(1151);
+			setState(1099);
 			_errHandler.sync(this);
-			_alt = getInterpreter().adaptivePredict(_input,140,_ctx);
+			_alt = getInterpreter().adaptivePredict(_input,129,_ctx);
 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 				if ( _alt==1 ) {
 					{
 					{
-					setState(1147);
+					setState(1095);
 					match(COMMA);
-					setState(1148);
+					setState(1096);
 					elementValue();
 					}
 					} 
 				}
-				setState(1153);
+				setState(1101);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,140,_ctx);
+				_alt = getInterpreter().adaptivePredict(_input,129,_ctx);
 			}
 			}
 		}
@@ -7521,17 +7892,22 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitMarkerAnnotation(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitMarkerAnnotation(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final MarkerAnnotationContext markerAnnotation() throws RecognitionException {
 		MarkerAnnotationContext _localctx = new MarkerAnnotationContext(_ctx, getState());
-		enterRule(_localctx, 226, RULE_markerAnnotation);
+		enterRule(_localctx, 224, RULE_markerAnnotation);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1154);
+			setState(1102);
 			match(AT);
-			setState(1155);
+			setState(1103);
 			typeName();
 			}
 		}
@@ -7565,23 +7941,28 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitSingleElementAnnotation(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitSingleElementAnnotation(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final SingleElementAnnotationContext singleElementAnnotation() throws RecognitionException {
 		SingleElementAnnotationContext _localctx = new SingleElementAnnotationContext(_ctx, getState());
-		enterRule(_localctx, 228, RULE_singleElementAnnotation);
+		enterRule(_localctx, 226, RULE_singleElementAnnotation);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1157);
+			setState(1105);
 			match(AT);
-			setState(1158);
+			setState(1106);
 			typeName();
-			setState(1159);
+			setState(1107);
 			match(LPAREN);
-			setState(1160);
+			setState(1108);
 			elementValue();
-			setState(1161);
+			setState(1109);
 			match(RPAREN);
 			}
 		}
@@ -7612,36 +7993,41 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitArrayInitializer(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitArrayInitializer(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final ArrayInitializerContext arrayInitializer() throws RecognitionException {
 		ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState());
-		enterRule(_localctx, 230, RULE_arrayInitializer);
+		enterRule(_localctx, 228, RULE_arrayInitializer);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1163);
+			setState(1111);
 			match(LBRACE);
-			setState(1165);
-			switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) {
+			setState(1113);
+			switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
 			case 1:
 				{
-				setState(1164);
+				setState(1112);
 				variableInitializerList();
 				}
 				break;
 			}
-			setState(1168);
+			setState(1116);
 			_la = _input.LA(1);
 			if (_la==COMMA) {
 				{
-				setState(1167);
+				setState(1115);
 				match(COMMA);
 				}
 			}
 
-			setState(1170);
+			setState(1118);
 			match(RBRACE);
 			}
 		}
@@ -7675,34 +8061,39 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitVariableInitializerList(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitVariableInitializerList(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final VariableInitializerListContext variableInitializerList() throws RecognitionException {
 		VariableInitializerListContext _localctx = new VariableInitializerListContext(_ctx, getState());
-		enterRule(_localctx, 232, RULE_variableInitializerList);
+		enterRule(_localctx, 230, RULE_variableInitializerList);
 		try {
 			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1172);
+			setState(1120);
 			variableInitializer();
-			setState(1177);
+			setState(1125);
 			_errHandler.sync(this);
-			_alt = getInterpreter().adaptivePredict(_input,143,_ctx);
+			_alt = getInterpreter().adaptivePredict(_input,132,_ctx);
 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 				if ( _alt==1 ) {
 					{
 					{
-					setState(1173);
+					setState(1121);
 					match(COMMA);
-					setState(1174);
+					setState(1122);
 					variableInitializer();
 					}
 					} 
 				}
-				setState(1179);
+				setState(1127);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,143,_ctx);
+				_alt = getInterpreter().adaptivePredict(_input,132,_ctx);
 			}
 			}
 		}
@@ -7733,26 +8124,24 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitBlock(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitBlock(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final BlockContext block() throws RecognitionException {
 		BlockContext _localctx = new BlockContext(_ctx, getState());
-		enterRule(_localctx, 234, RULE_block);
+		enterRule(_localctx, 232, RULE_block);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1180);
+			setState(1128);
 			match(LBRACE);
-			setState(1182);
-			switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) {
-			case 1:
-				{
-				setState(1181);
-				blockStatements();
-				}
-				break;
-			}
-			setState(1184);
+			setState(1129);
+			blockStatements();
+			setState(1130);
 			match(RBRACE);
 			}
 		}
@@ -7780,35 +8169,36 @@ public void enterRule(ParseTreeListener listener) {
 		public void exitRule(ParseTreeListener listener) {
 			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitBlockStatements(this);
 		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitBlockStatements(this);
+			else return visitor.visitChildren(this);
+		}
 	}
 
 	public final BlockStatementsContext blockStatements() throws RecognitionException {
 		BlockStatementsContext _localctx = new BlockStatementsContext(_ctx, getState());
-		enterRule(_localctx, 236, RULE_blockStatements);
+		enterRule(_localctx, 234, RULE_blockStatements);
 		try {
 			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1187); 
+			setState(1135);
 			_errHandler.sync(this);
-			_alt = 1+1;
-			do {
-				switch (_alt) {
-				case 1+1:
+			_alt = getInterpreter().adaptivePredict(_input,133,_ctx);
+			while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1+1 ) {
 					{
 					{
-					setState(1186);
+					setState(1132);
 					matchWildcard();
 					}
-					}
-					break;
-				default:
-					throw new NoViableAltException(this);
+					} 
 				}
-				setState(1189); 
+				setState(1137);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,145,_ctx);
-			} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+				_alt = getInterpreter().adaptivePredict(_input,133,_ctx);
+			}
 			}
 		}
 		catch (RecognitionException re) {
@@ -7826,8 +8216,6 @@ public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
 		switch (ruleIndex) {
 		case 25:
 			return packageOrTypeName_sempred((PackageOrTypeNameContext)_localctx, predIndex);
-		case 27:
-			return ambiguousName_sempred((AmbiguousNameContext)_localctx, predIndex);
 		}
 		return true;
 	}
@@ -7838,16 +8226,9 @@ private boolean packageOrTypeName_sempred(PackageOrTypeNameContext _localctx, in
 		}
 		return true;
 	}
-	private boolean ambiguousName_sempred(AmbiguousNameContext _localctx, int predIndex) {
-		switch (predIndex) {
-		case 1:
-			return precpred(_ctx, 1);
-		}
-		return true;
-	}
 
 	public static final String _serializedATN =
-		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3m\u04aa\4\2\t\2\4"+
+		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3m\u0475\4\2\t\2\4"+
 		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
 		"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
 		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
@@ -7860,445 +8241,424 @@ private boolean ambiguousName_sempred(AmbiguousNameContext _localctx, int predIn
 		"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
 		"`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
 		"k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
-		"w\tw\4x\tx\3\2\7\2\u00f2\n\2\f\2\16\2\u00f5\13\2\3\2\3\2\7\2\u00f9\n\2"+
-		"\f\2\16\2\u00fc\13\2\3\2\5\2\u00ff\n\2\3\3\3\3\5\3\u0103\n\3\3\4\3\4\3"+
-		"\5\3\5\3\6\3\6\3\6\5\6\u010c\n\6\3\7\3\7\5\7\u0110\n\7\3\7\3\7\7\7\u0114"+
-		"\n\7\f\7\16\7\u0117\13\7\3\b\7\b\u011a\n\b\f\b\16\b\u011d\13\b\3\b\3\b"+
-		"\5\b\u0121\n\b\3\b\3\b\3\b\7\b\u0126\n\b\f\b\16\b\u0129\13\b\3\b\3\b\5"+
-		"\b\u012d\n\b\5\b\u012f\n\b\3\t\3\t\7\t\u0133\n\t\f\t\16\t\u0136\13\t\3"+
-		"\t\3\t\5\t\u013a\n\t\3\n\7\n\u013d\n\n\f\n\16\n\u0140\13\n\3\n\3\n\5\n"+
-		"\u0144\n\n\3\13\3\13\3\f\3\f\3\r\3\r\3\16\7\16\u014d\n\16\f\16\16\16\u0150"+
-		"\13\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\5\17\u015d"+
-		"\n\17\3\20\7\20\u0160\n\20\f\20\16\20\u0163\13\20\3\20\3\20\3\20\7\20"+
-		"\u0168\n\20\f\20\16\20\u016b\13\20\3\20\3\20\7\20\u016f\n\20\f\20\16\20"+
-		"\u0172\13\20\3\21\7\21\u0175\n\21\f\21\16\21\u0178\13\21\3\21\3\21\5\21"+
-		"\u017c\n\21\3\22\3\22\3\23\3\23\3\23\3\23\3\23\7\23\u0185\n\23\f\23\16"+
-		"\23\u0188\13\23\5\23\u018a\n\23\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\26"+
-		"\3\26\3\26\7\26\u0196\n\26\f\26\16\26\u0199\13\26\3\27\3\27\5\27\u019d"+
-		"\n\27\3\30\7\30\u01a0\n\30\f\30\16\30\u01a3\13\30\3\30\3\30\5\30\u01a7"+
-		"\n\30\3\31\3\31\3\31\3\31\5\31\u01ad\n\31\3\32\3\32\3\32\3\32\3\32\5\32"+
-		"\u01b4\n\32\3\33\3\33\3\33\3\33\3\33\3\33\7\33\u01bc\n\33\f\33\16\33\u01bf"+
-		"\13\33\3\34\3\34\3\34\3\34\3\34\5\34\u01c6\n\34\3\35\3\35\3\35\3\35\3"+
-		"\35\3\35\7\35\u01ce\n\35\f\35\16\35\u01d1\13\35\3\36\5\36\u01d4\n\36\3"+
-		"\36\7\36\u01d7\n\36\f\36\16\36\u01da\13\36\3\36\7\36\u01dd\n\36\f\36\16"+
-		"\36\u01e0\13\36\3\36\3\36\3\37\7\37\u01e5\n\37\f\37\16\37\u01e8\13\37"+
-		"\3\37\3\37\3\37\3\37\7\37\u01ee\n\37\f\37\16\37\u01f1\13\37\3\37\3\37"+
-		"\3 \3 \3!\3!\3!\3!\5!\u01fb\n!\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3#\3#\3$\3"+
-		"$\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3&\3&\3&\5&\u0218\n&\3\'\3\'\5\'"+
-		"\u021c\n\'\3(\7(\u021f\n(\f(\16(\u0222\13(\3(\3(\3(\5(\u0227\n(\3(\5("+
-		"\u022a\n(\3(\5(\u022d\n(\3(\3(\3)\3)\3)\3)\3)\3)\3)\3)\5)\u0239\n)\3*"+
-		"\3*\3*\3*\3+\3+\3+\7+\u0242\n+\f+\16+\u0245\13+\3,\3,\3,\3-\3-\3-\3.\3"+
-		".\3.\7.\u0250\n.\f.\16.\u0253\13.\3/\3/\7/\u0257\n/\f/\16/\u025a\13/\3"+
-		"/\3/\3\60\3\60\3\60\3\60\5\60\u0262\n\60\3\61\3\61\3\61\3\61\3\61\5\61"+
-		"\u0269\n\61\3\62\6\62\u026c\n\62\r\62\16\62\u026d\3\62\3\62\3\63\3\63"+
-		"\5\63\u0274\n\63\3\64\3\64\5\64\u0278\n\64\3\65\3\65\5\65\u027c\n\65\3"+
-		"\66\3\66\5\66\u0280\n\66\3\67\3\67\3\67\5\67\u0285\n\67\38\38\58\u0289"+
-		"\n8\38\38\78\u028d\n8\f8\168\u0290\138\39\39\79\u0294\n9\f9\169\u0297"+
-		"\139\39\39\59\u029b\n9\3:\3:\5:\u029f\n:\3;\3;\3<\3<\3=\3=\3>\3>\3>\3"+
-		">\3>\3>\3>\3>\3>\5>\u02b0\n>\3?\7?\u02b3\n?\f?\16?\u02b6\13?\3?\3?\3?"+
-		"\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\5@\u02c5\n@\3A\3A\3A\5A\u02ca\nA\3A\3A"+
-		"\7A\u02ce\nA\fA\16A\u02d1\13A\3A\3A\3A\5A\u02d6\nA\5A\u02d8\nA\3B\3B\5"+
-		"B\u02dc\nB\3C\3C\3C\5C\u02e1\nC\3C\3C\5C\u02e5\nC\3D\3D\3D\3D\3D\5D\u02ec"+
-		"\nD\3E\3E\3E\7E\u02f1\nE\fE\16E\u02f4\13E\3E\3E\3E\7E\u02f9\nE\fE\16E"+
-		"\u02fc\13E\5E\u02fe\nE\3F\7F\u0301\nF\fF\16F\u0304\13F\3F\3F\3F\3G\3G"+
-		"\5G\u030b\nG\3H\7H\u030e\nH\fH\16H\u0311\13H\3H\3H\7H\u0315\nH\fH\16H"+
-		"\u0318\13H\3H\3H\3H\3H\5H\u031e\nH\3I\7I\u0321\nI\fI\16I\u0324\13I\3I"+
-		"\3I\3I\5I\u0329\nI\3I\3I\3J\3J\3J\3K\3K\3K\7K\u0333\nK\fK\16K\u0336\13"+
-		"K\3L\3L\5L\u033a\nL\3M\3M\5M\u033e\nM\3N\3N\3O\3O\3O\3P\7P\u0346\nP\f"+
-		"P\16P\u0349\13P\3P\3P\5P\u034d\nP\3P\3P\3Q\3Q\3Q\3Q\5Q\u0355\nQ\3R\5R"+
-		"\u0358\nR\3R\3R\3R\5R\u035d\nR\3R\3R\3S\3S\3T\3T\5T\u0365\nT\3T\5T\u0368"+
-		"\nT\3T\3T\3U\5U\u036d\nU\3U\3U\3U\5U\u0372\nU\3U\3U\3U\5U\u0377\nU\3U"+
-		"\3U\3U\5U\u037c\nU\3U\3U\3U\3U\3U\5U\u0383\nU\3U\3U\3U\5U\u0388\nU\3U"+
-		"\3U\3U\3U\3U\3U\5U\u0390\nU\3U\3U\3U\5U\u0395\nU\3U\3U\3U\5U\u039a\nU"+
-		"\3V\7V\u039d\nV\fV\16V\u03a0\13V\3V\3V\3V\5V\u03a5\nV\3V\3V\3W\3W\5W\u03ab"+
-		"\nW\3W\5W\u03ae\nW\3W\5W\u03b1\nW\3W\3W\3X\3X\3X\7X\u03b8\nX\fX\16X\u03bb"+
-		"\13X\3Y\7Y\u03be\nY\fY\16Y\u03c1\13Y\3Y\3Y\3Y\5Y\u03c6\nY\3Y\5Y\u03c9"+
-		"\nY\3Y\5Y\u03cc\nY\3Z\3Z\3[\3[\7[\u03d2\n[\f[\16[\u03d5\13[\3\\\3\\\3"+
-		"\\\7\\\u03da\n\\\f\\\16\\\u03dd\13\\\3]\6]\u03e0\n]\r]\16]\u03e1\3^\6"+
-		"^\u03e5\n^\r^\16^\u03e6\3_\6_\u03ea\n_\r_\16_\u03eb\3`\3`\5`\u03f0\n`"+
-		"\3a\7a\u03f3\na\fa\16a\u03f6\13a\3a\3a\3a\5a\u03fb\na\3a\5a\u03fe\na\3"+
-		"a\3a\3b\3b\3b\3b\3b\3b\3b\5b\u0409\nb\3c\3c\3c\3d\3d\7d\u0410\nd\fd\16"+
-		"d\u0413\13d\3d\3d\3e\3e\3e\3e\3e\5e\u041c\ne\3f\7f\u041f\nf\ff\16f\u0422"+
-		"\13f\3f\3f\6f\u0426\nf\rf\16f\u0427\3f\3f\3g\3g\3g\3g\5g\u0430\ng\3h\7"+
-		"h\u0433\nh\fh\16h\u0436\13h\3h\3h\3h\3i\3i\3i\3i\3i\3i\5i\u0441\ni\3j"+
-		"\7j\u0444\nj\fj\16j\u0447\13j\3j\3j\3j\3j\3j\3k\3k\6k\u0450\nk\rk\16k"+
-		"\u0451\3k\3k\3l\3l\3l\5l\u0459\nl\3m\3m\3m\3m\5m\u045f\nm\3m\3m\3n\3n"+
-		"\3n\7n\u0466\nn\fn\16n\u0469\13n\3o\3o\3o\3o\3p\3p\3p\5p\u0472\np\3q\3"+
-		"q\5q\u0476\nq\3q\5q\u0479\nq\3q\3q\3r\3r\3r\7r\u0480\nr\fr\16r\u0483\13"+
-		"r\3s\3s\3s\3t\3t\3t\3t\3t\3t\3u\3u\5u\u0490\nu\3u\5u\u0493\nu\3u\3u\3"+
-		"v\3v\3v\7v\u049a\nv\fv\16v\u049d\13v\3w\3w\5w\u04a1\nw\3w\3w\3x\6x\u04a6"+
-		"\nx\rx\16x\u04a7\3x\t\u026d\u03e1\u03e6\u03eb\u0427\u0451\u04a7\4\648"+
-		"y\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDF"+
-		"HJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c"+
-		"\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4"+
-		"\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc"+
-		"\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4"+
-		"\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec"+
-		"\u00ee\2\4\7\2\7\7\n\n\35\35\37\37\'\'\4\2\20\20\26\26\u04f2\2\u00fe\3"+
-		"\2\2\2\4\u0102\3\2\2\2\6\u0104\3\2\2\2\b\u0106\3\2\2\2\n\u010b\3\2\2\2"+
-		"\f\u010f\3\2\2\2\16\u012e\3\2\2\2\20\u0130\3\2\2\2\22\u013e\3\2\2\2\24"+
-		"\u0145\3\2\2\2\26\u0147\3\2\2\2\30\u0149\3\2\2\2\32\u014e\3\2\2\2\34\u015c"+
-		"\3\2\2\2\36\u0161\3\2\2\2 \u0176\3\2\2\2\"\u017d\3\2\2\2$\u0189\3\2\2"+
-		"\2&\u018b\3\2\2\2(\u018e\3\2\2\2*\u0192\3\2\2\2,\u019c\3\2\2\2.\u01a1"+
-		"\3\2\2\2\60\u01ac\3\2\2\2\62\u01b3\3\2\2\2\64\u01b5\3\2\2\2\66\u01c5\3"+
-		"\2\2\28\u01c7\3\2\2\2:\u01d3\3\2\2\2<\u01e6\3\2\2\2>\u01f4\3\2\2\2@\u01fa"+
-		"\3\2\2\2B\u01fc\3\2\2\2D\u0200\3\2\2\2F\u0206\3\2\2\2H\u020d\3\2\2\2J"+
-		"\u0217\3\2\2\2L\u021b\3\2\2\2N\u0220\3\2\2\2P\u0238\3\2\2\2R\u023a\3\2"+
-		"\2\2T\u023e\3\2\2\2V\u0246\3\2\2\2X\u0249\3\2\2\2Z\u024c\3\2\2\2\\\u0254"+
-		"\3\2\2\2^\u0261\3\2\2\2`\u0268\3\2\2\2b\u026b\3\2\2\2d\u0271\3\2\2\2f"+
-		"\u0277\3\2\2\2h\u027b\3\2\2\2j\u027f\3\2\2\2l\u0284\3\2\2\2n\u0288\3\2"+
-		"\2\2p\u0291\3\2\2\2r\u029c\3\2\2\2t\u02a0\3\2\2\2v\u02a2\3\2\2\2x\u02a4"+
-		"\3\2\2\2z\u02af\3\2\2\2|\u02b4\3\2\2\2~\u02c4\3\2\2\2\u0080\u02d7\3\2"+
-		"\2\2\u0082\u02db\3\2\2\2\u0084\u02dd\3\2\2\2\u0086\u02eb\3\2\2\2\u0088"+
-		"\u02fd\3\2\2\2\u008a\u0302\3\2\2\2\u008c\u030a\3\2\2\2\u008e\u031d\3\2"+
-		"\2\2\u0090\u0322\3\2\2\2\u0092\u032c\3\2\2\2\u0094\u032f\3\2\2\2\u0096"+
-		"\u0339\3\2\2\2\u0098\u033d\3\2\2\2\u009a\u033f\3\2\2\2\u009c\u0341\3\2"+
-		"\2\2\u009e\u0347\3\2\2\2\u00a0\u0354\3\2\2\2\u00a2\u0357\3\2\2\2\u00a4"+
-		"\u0360\3\2\2\2\u00a6\u0362\3\2\2\2\u00a8\u0399\3\2\2\2\u00aa\u039e\3\2"+
-		"\2\2\u00ac\u03a8\3\2\2\2\u00ae\u03b4\3\2\2\2\u00b0\u03bf\3\2\2\2\u00b2"+
-		"\u03cd\3\2\2\2\u00b4\u03cf\3\2\2\2\u00b6\u03d6\3\2\2\2\u00b8\u03df\3\2"+
-		"\2\2\u00ba\u03e4\3\2\2\2\u00bc\u03e9\3\2\2\2\u00be\u03ef\3\2\2\2\u00c0"+
-		"\u03f4\3\2\2\2\u00c2\u0408\3\2\2\2\u00c4\u040a\3\2\2\2\u00c6\u040d\3\2"+
-		"\2\2\u00c8\u041b\3\2\2\2\u00ca\u0420\3\2\2\2\u00cc\u042f\3\2\2\2\u00ce"+
-		"\u0434\3\2\2\2\u00d0\u0440\3\2\2\2\u00d2\u0445\3\2\2\2\u00d4\u044d\3\2"+
-		"\2\2\u00d6\u0458\3\2\2\2\u00d8\u045a\3\2\2\2\u00da\u0462\3\2\2\2\u00dc"+
-		"\u046a\3\2\2\2\u00de\u0471\3\2\2\2\u00e0\u0473\3\2\2\2\u00e2\u047c\3\2"+
-		"\2\2\u00e4\u0484\3\2\2\2\u00e6\u0487\3\2\2\2\u00e8\u048d\3\2\2\2\u00ea"+
-		"\u0496\3\2\2\2\u00ec\u049e\3\2\2\2\u00ee\u04a5\3\2\2\2\u00f0\u00f2\5\u00d6"+
-		"l\2\u00f1\u00f0\3\2\2\2\u00f2\u00f5\3\2\2\2\u00f3\u00f1\3\2\2\2\u00f3"+
-		"\u00f4\3\2\2\2\u00f4\u00f6\3\2\2\2\u00f5\u00f3\3\2\2\2\u00f6\u00ff\5\4"+
-		"\3\2\u00f7\u00f9\5\u00d6l\2\u00f8\u00f7\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa"+
-		"\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb\u00fd\3\2\2\2\u00fc\u00fa\3\2"+
-		"\2\2\u00fd\u00ff\7\5\2\2\u00fe\u00f3\3\2\2\2\u00fe\u00fa\3\2\2\2\u00ff"+
-		"\3\3\2\2\2\u0100\u0103\5\6\4\2\u0101\u0103\5\b\5\2\u0102\u0100\3\2\2\2"+
-		"\u0102\u0101\3\2\2\2\u0103\5\3\2\2\2\u0104\u0105\t\2\2\2\u0105\7\3\2\2"+
-		"\2\u0106\u0107\t\3\2\2\u0107\t\3\2\2\2\u0108\u010c\5\f\7\2\u0109\u010c"+
-		"\5\32\16\2\u010a\u010c\5\34\17\2\u010b\u0108\3\2\2\2\u010b\u0109\3\2\2"+
-		"\2\u010b\u010a\3\2\2\2\u010c\13\3\2\2\2\u010d\u0110\5\22\n\2\u010e\u0110"+
-		"\5\30\r\2\u010f\u010d\3\2\2\2\u010f\u010e\3\2\2\2\u0110\u0115\3\2\2\2"+
-		"\u0111\u0114\5\20\t\2\u0112\u0114\5\26\f\2\u0113\u0111\3\2\2\2\u0113\u0112"+
-		"\3\2\2\2\u0114\u0117\3\2\2\2\u0115\u0113\3\2\2\2\u0115\u0116\3\2\2\2\u0116"+
-		"\r\3\2\2\2\u0117\u0115\3\2\2\2\u0118\u011a\5\u00d6l\2\u0119\u0118\3\2"+
-		"\2\2\u011a\u011d\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011c\3\2\2\2\u011c"+
-		"\u011e\3\2\2\2\u011d\u011b\3\2\2\2\u011e\u0120\7h\2\2\u011f\u0121\5(\25"+
-		"\2\u0120\u011f\3\2\2\2\u0120\u0121\3\2\2\2\u0121\u012f\3\2\2\2\u0122\u0123"+
-		"\5\f\7\2\u0123\u0127\7C\2\2\u0124\u0126\5\u00d6l\2\u0125\u0124\3\2\2\2"+
-		"\u0126\u0129\3\2\2\2\u0127\u0125\3\2\2\2\u0127\u0128\3\2\2\2\u0128\u012a"+
-		"\3\2\2\2\u0129\u0127\3\2\2\2\u012a\u012c\7h\2\2\u012b\u012d\5(\25\2\u012c"+
-		"\u012b\3\2\2\2\u012c\u012d\3\2\2\2\u012d\u012f\3\2\2\2\u012e\u011b\3\2"+
-		"\2\2\u012e\u0122\3\2\2\2\u012f\17\3\2\2\2\u0130\u0134\7C\2\2\u0131\u0133"+
-		"\5\u00d6l\2\u0132\u0131\3\2\2\2\u0133\u0136\3\2\2\2\u0134\u0132\3\2\2"+
-		"\2\u0134\u0135\3\2\2\2\u0135\u0137\3\2\2\2\u0136\u0134\3\2\2\2\u0137\u0139"+
-		"\7h\2\2\u0138\u013a\5(\25\2\u0139\u0138\3\2\2\2\u0139\u013a\3\2\2\2\u013a"+
-		"\21\3\2\2\2\u013b\u013d\5\u00d6l\2\u013c\u013b\3\2\2\2\u013d\u0140\3\2"+
-		"\2\2\u013e\u013c\3\2\2\2\u013e\u013f\3\2\2\2\u013f\u0141\3\2\2\2\u0140"+
-		"\u013e\3\2\2\2\u0141\u0143\7h\2\2\u0142\u0144\5(\25\2\u0143\u0142\3\2"+
-		"\2\2\u0143\u0144\3\2\2\2\u0144\23\3\2\2\2\u0145\u0146\5\16\b\2\u0146\25"+
-		"\3\2\2\2\u0147\u0148\5\20\t\2\u0148\27\3\2\2\2\u0149\u014a\5\22\n\2\u014a"+
-		"\31\3\2\2\2\u014b\u014d\5\u00d6l\2\u014c\u014b\3\2\2\2\u014d\u0150\3\2"+
-		"\2\2\u014e\u014c\3\2\2\2\u014e\u014f\3\2\2\2\u014f\u0151\3\2\2\2\u0150"+
-		"\u014e\3\2\2\2\u0151\u0152\7h\2\2\u0152\33\3\2\2\2\u0153\u0154\5\2\2\2"+
-		"\u0154\u0155\5\36\20\2\u0155\u015d\3\2\2\2\u0156\u0157\5\f\7\2\u0157\u0158"+
-		"\5\36\20\2\u0158\u015d\3\2\2\2\u0159\u015a\5\32\16\2\u015a\u015b\5\36"+
-		"\20\2\u015b\u015d\3\2\2\2\u015c\u0153\3\2\2\2\u015c\u0156\3\2\2\2\u015c"+
-		"\u0159\3\2\2\2\u015d\35\3\2\2\2\u015e\u0160\5\u00d6l\2\u015f\u015e\3\2"+
-		"\2\2\u0160\u0163\3\2\2\2\u0161\u015f\3\2\2\2\u0161\u0162\3\2\2\2\u0162"+
-		"\u0164\3\2\2\2\u0163\u0161\3\2\2\2\u0164\u0165\7?\2\2\u0165\u0170\7@\2"+
-		"\2\u0166\u0168\5\u00d6l\2\u0167\u0166\3\2\2\2\u0168\u016b\3\2\2\2\u0169"+
-		"\u0167\3\2\2\2\u0169\u016a\3\2\2\2\u016a\u016c\3\2\2\2\u016b\u0169\3\2"+
-		"\2\2\u016c\u016d\7?\2\2\u016d\u016f\7@\2\2\u016e\u0169\3\2\2\2\u016f\u0172"+
-		"\3\2\2\2\u0170\u016e\3\2\2\2\u0170\u0171\3\2\2\2\u0171\37\3\2\2\2\u0172"+
-		"\u0170\3\2\2\2\u0173\u0175\5\"\22\2\u0174\u0173\3\2\2\2\u0175\u0178\3"+
-		"\2\2\2\u0176\u0174\3\2\2\2\u0176\u0177\3\2\2\2\u0177\u0179\3\2\2\2\u0178"+
-		"\u0176\3\2\2\2\u0179\u017b\7h\2\2\u017a\u017c\5$\23\2\u017b\u017a\3\2"+
-		"\2\2\u017b\u017c\3\2\2\2\u017c!\3\2\2\2\u017d\u017e\5\u00d6l\2\u017e#"+
-		"\3\2\2\2\u017f\u0180\7\23\2\2\u0180\u018a\5\32\16\2\u0181\u0182\7\23\2"+
-		"\2\u0182\u0186\5\f\7\2\u0183\u0185\5&\24\2\u0184\u0183\3\2\2\2\u0185\u0188"+
-		"\3\2\2\2\u0186\u0184\3\2\2\2\u0186\u0187\3\2\2\2\u0187\u018a\3\2\2\2\u0188"+
-		"\u0186\3\2\2\2\u0189\u017f\3\2\2\2\u0189\u0181\3\2\2\2\u018a%\3\2\2\2"+
-		"\u018b\u018c\7W\2\2\u018c\u018d\5\24\13\2\u018d\'\3\2\2\2\u018e\u018f"+
-		"\7F\2\2\u018f\u0190\5*\26\2\u0190\u0191\7E\2\2\u0191)\3\2\2\2\u0192\u0197"+
-		"\5,\27\2\u0193\u0194\7B\2\2\u0194\u0196\5,\27\2\u0195\u0193\3\2\2\2\u0196"+
-		"\u0199\3\2\2\2\u0197\u0195\3\2\2\2\u0197\u0198\3\2\2\2\u0198+\3\2\2\2"+
-		"\u0199\u0197\3\2\2\2\u019a\u019d\5\n\6\2\u019b\u019d\5.\30\2\u019c\u019a"+
-		"\3\2\2\2\u019c\u019b\3\2\2\2\u019d-\3\2\2\2\u019e\u01a0\5\u00d6l\2\u019f"+
-		"\u019e\3\2\2\2\u01a0\u01a3\3\2\2\2\u01a1\u019f\3\2\2\2\u01a1\u01a2\3\2"+
-		"\2\2\u01a2\u01a4\3\2\2\2\u01a3\u01a1\3\2\2\2\u01a4\u01a6\7I\2\2\u01a5"+
-		"\u01a7\5\60\31\2\u01a6\u01a5\3\2\2\2\u01a6\u01a7\3\2\2\2\u01a7/\3\2\2"+
-		"\2\u01a8\u01a9\7\23\2\2\u01a9\u01ad\5\n\6\2\u01aa\u01ab\7*\2\2\u01ab\u01ad"+
-		"\5\n\6\2\u01ac\u01a8\3\2\2\2\u01ac\u01aa\3\2\2\2\u01ad\61\3\2\2\2\u01ae"+
-		"\u01b4\7h\2\2\u01af\u01b0\5\64\33\2\u01b0\u01b1\7C\2\2\u01b1\u01b2\7h"+
-		"\2\2\u01b2\u01b4\3\2\2\2\u01b3\u01ae\3\2\2\2\u01b3\u01af\3\2\2\2\u01b4"+
-		"\63\3\2\2\2\u01b5\u01b6\b\33\1\2\u01b6\u01b7\7h\2\2\u01b7\u01bd\3\2\2"+
-		"\2\u01b8\u01b9\f\3\2\2\u01b9\u01ba\7C\2\2\u01ba\u01bc\7h\2\2\u01bb\u01b8"+
-		"\3\2\2\2\u01bc\u01bf\3\2\2\2\u01bd\u01bb\3\2\2\2\u01bd\u01be\3\2\2\2\u01be"+
-		"\65\3\2\2\2\u01bf\u01bd\3\2\2\2\u01c0\u01c6\7h\2\2\u01c1\u01c2\58\35\2"+
-		"\u01c2\u01c3\7C\2\2\u01c3\u01c4\7h\2\2\u01c4\u01c6\3\2\2\2\u01c5\u01c0"+
-		"\3\2\2\2\u01c5\u01c1\3\2\2\2\u01c6\67\3\2\2\2\u01c7\u01c8\b\35\1\2\u01c8"+
-		"\u01c9\7h\2\2\u01c9\u01cf\3\2\2\2\u01ca\u01cb\f\3\2\2\u01cb\u01cc\7C\2"+
-		"\2\u01cc\u01ce\7h\2\2\u01cd\u01ca\3\2\2\2\u01ce\u01d1\3\2\2\2\u01cf\u01cd"+
-		"\3\2\2\2\u01cf\u01d0\3\2\2\2\u01d09\3\2\2\2\u01d1\u01cf\3\2\2\2\u01d2"+
-		"\u01d4\5<\37\2\u01d3\u01d2\3\2\2\2\u01d3\u01d4\3\2\2\2\u01d4\u01d8\3\2"+
-		"\2\2\u01d5\u01d7\5@!\2\u01d6\u01d5\3\2\2\2\u01d7\u01da\3\2\2\2\u01d8\u01d6"+
-		"\3\2\2\2\u01d8\u01d9\3\2\2\2\u01d9\u01de\3\2\2\2\u01da\u01d8\3\2\2\2\u01db"+
-		"\u01dd\5J&\2\u01dc\u01db\3\2\2\2\u01dd\u01e0\3\2\2\2\u01de\u01dc\3\2\2"+
-		"\2\u01de\u01df\3\2\2\2\u01df\u01e1\3\2\2\2\u01e0\u01de\3\2\2\2\u01e1\u01e2"+
-		"\7\2\2\3\u01e2;\3\2\2\2\u01e3\u01e5\5> \2\u01e4\u01e3\3\2\2\2\u01e5\u01e8"+
-		"\3\2\2\2\u01e6\u01e4\3\2\2\2\u01e6\u01e7\3\2\2\2\u01e7\u01e9\3\2\2\2\u01e8"+
-		"\u01e6\3\2\2\2\u01e9\u01ea\7\"\2\2\u01ea\u01ef\7h\2\2\u01eb\u01ec\7C\2"+
-		"\2\u01ec\u01ee\7h\2\2\u01ed\u01eb\3\2\2\2\u01ee\u01f1\3\2\2\2\u01ef\u01ed"+
-		"\3\2\2\2\u01ef\u01f0\3\2\2\2\u01f0\u01f2\3\2\2\2\u01f1\u01ef\3\2\2\2\u01f2"+
-		"\u01f3\7A\2\2\u01f3=\3\2\2\2\u01f4\u01f5\5\u00d6l\2\u01f5?\3\2\2\2\u01f6"+
-		"\u01fb\5B\"\2\u01f7\u01fb\5D#\2\u01f8\u01fb\5F$\2\u01f9\u01fb\5H%\2\u01fa"+
-		"\u01f6\3\2\2\2\u01fa\u01f7\3\2\2\2\u01fa\u01f8\3\2\2\2\u01fa\u01f9\3\2"+
-		"\2\2\u01fbA\3\2\2\2\u01fc\u01fd\7\33\2\2\u01fd\u01fe\5\62\32\2\u01fe\u01ff"+
-		"\7A\2\2\u01ffC\3\2\2\2\u0200\u0201\7\33\2\2\u0201\u0202\5\64\33\2\u0202"+
-		"\u0203\7C\2\2\u0203\u0204\7U\2\2\u0204\u0205\7A\2\2\u0205E\3\2\2\2\u0206"+
-		"\u0207\7\33\2\2\u0207\u0208\7(\2\2\u0208\u0209\5\62\32\2\u0209\u020a\7"+
-		"C\2\2\u020a\u020b\7h\2\2\u020b\u020c\7A\2\2\u020cG\3\2\2\2\u020d\u020e"+
-		"\7\33\2\2\u020e\u020f\7(\2\2\u020f\u0210\5\62\32\2\u0210\u0211\7C\2\2"+
-		"\u0211\u0212\7U\2\2\u0212\u0213\7A\2\2\u0213I\3\2\2\2\u0214\u0218\5L\'"+
-		"\2\u0215\u0218\5\u00be`\2\u0216\u0218\7A\2\2\u0217\u0214\3\2\2\2\u0217"+
-		"\u0215\3\2\2\2\u0217\u0216\3\2\2\2\u0218K\3\2\2\2\u0219\u021c\5N(\2\u021a"+
-		"\u021c\5\u00aaV\2\u021b\u0219\3\2\2\2\u021b\u021a\3\2\2\2\u021cM\3\2\2"+
-		"\2\u021d\u021f\5P)\2\u021e\u021d\3\2\2\2\u021f\u0222\3\2\2\2\u0220\u021e"+
-		"\3\2\2\2\u0220\u0221\3\2\2\2\u0221\u0223\3\2\2\2\u0222\u0220\3\2\2\2\u0223"+
-		"\u0224\7\13\2\2\u0224\u0226\7h\2\2\u0225\u0227\5R*\2\u0226\u0225\3\2\2"+
-		"\2\u0226\u0227\3\2\2\2\u0227\u0229\3\2\2\2\u0228\u022a\5V,\2\u0229\u0228"+
-		"\3\2\2\2\u0229\u022a\3\2\2\2\u022a\u022c\3\2\2\2\u022b\u022d\5X-\2\u022c"+
-		"\u022b\3\2\2\2\u022c\u022d\3\2\2\2\u022d\u022e\3\2\2\2\u022e\u022f\5\\"+
-		"/\2\u022fO\3\2\2\2\u0230\u0239\5\u00d6l\2\u0231\u0239\7%\2\2\u0232\u0239"+
-		"\7$\2\2\u0233\u0239\7#\2\2\u0234\u0239\7\3\2\2\u0235\u0239\7(\2\2\u0236"+
-		"\u0239\7\24\2\2\u0237\u0239\7)\2\2\u0238\u0230\3\2\2\2\u0238\u0231\3\2"+
-		"\2\2\u0238\u0232\3\2\2\2\u0238\u0233\3\2\2\2\u0238\u0234\3\2\2\2\u0238"+
-		"\u0235\3\2\2\2\u0238\u0236\3\2\2\2\u0238\u0237\3\2\2\2\u0239Q\3\2\2\2"+
-		"\u023a\u023b\7F\2\2\u023b\u023c\5T+\2\u023c\u023d\7E\2\2\u023dS\3\2\2"+
-		"\2\u023e\u0243\5 \21\2\u023f\u0240\7B\2\2\u0240\u0242\5 \21\2\u0241\u023f"+
-		"\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243\u0244\3\2\2\2\u0244"+
-		"U\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\7\23\2\2\u0247\u0248\5\16\b"+
-		"\2\u0248W\3\2\2\2\u0249\u024a\7\32\2\2\u024a\u024b\5Z.\2\u024bY\3\2\2"+
-		"\2\u024c\u0251\5\24\13\2\u024d\u024e\7B\2\2\u024e\u0250\5\24\13\2\u024f"+
-		"\u024d\3\2\2\2\u0250\u0253\3\2\2\2\u0251\u024f\3\2\2\2\u0251\u0252\3\2"+
-		"\2\2\u0252[\3\2\2\2\u0253\u0251\3\2\2\2\u0254\u0258\7=\2\2\u0255\u0257"+
-		"\5^\60\2\u0256\u0255\3\2\2\2\u0257\u025a\3\2\2\2\u0258\u0256\3\2\2\2\u0258"+
-		"\u0259\3\2\2\2\u0259\u025b\3\2\2\2\u025a\u0258\3\2\2\2\u025b\u025c\7>"+
-		"\2\2\u025c]\3\2\2\2\u025d\u0262\5`\61\2\u025e\u0262\5\u009aN\2\u025f\u0262"+
-		"\5\u009cO\2\u0260\u0262\5\u009eP\2\u0261\u025d\3\2\2\2\u0261\u025e\3\2"+
-		"\2\2\u0261\u025f\3\2\2\2\u0261\u0260\3\2\2\2\u0262_\3\2\2\2\u0263\u0269"+
-		"\5b\62\2\u0264\u0269\5|?\2\u0265\u0269\5L\'\2\u0266\u0269\5\u00be`\2\u0267"+
-		"\u0269\7A\2\2\u0268\u0263\3\2\2\2\u0268\u0264\3\2\2\2\u0268\u0265\3\2"+
-		"\2\2\u0268\u0266\3\2\2\2\u0268\u0267\3\2\2\2\u0269a\3\2\2\2\u026a\u026c"+
-		"\13\2\2\2\u026b\u026a\3\2\2\2\u026c\u026d\3\2\2\2\u026d\u026e\3\2\2\2"+
-		"\u026d\u026b\3\2\2\2\u026e\u026f\3\2\2\2\u026f\u0270\7A\2\2\u0270c\3\2"+
-		"\2\2\u0271\u0273\7h\2\2\u0272\u0274\5\36\20\2\u0273\u0272\3\2\2\2\u0273"+
-		"\u0274\3\2\2\2\u0274e\3\2\2\2\u0275\u0278\5\u00b8]\2\u0276\u0278\5\u00e8"+
-		"u\2\u0277\u0275\3\2\2\2\u0277\u0276\3\2\2\2\u0278g\3\2\2\2\u0279\u027c"+
-		"\5j\66\2\u027a\u027c\5l\67\2\u027b\u0279\3\2\2\2\u027b\u027a\3\2\2\2\u027c"+
-		"i\3\2\2\2\u027d\u0280\5\4\3\2\u027e\u0280\7\5\2\2\u027f\u027d\3\2\2\2"+
-		"\u027f\u027e\3\2\2\2\u0280k\3\2\2\2\u0281\u0285\5n8\2\u0282\u0285\5x="+
-		"\2\u0283\u0285\5z>\2\u0284\u0281\3\2\2\2\u0284\u0282\3\2\2\2\u0284\u0283"+
-		"\3\2\2\2\u0285m\3\2\2\2\u0286\u0289\5r:\2\u0287\u0289\5v<\2\u0288\u0286"+
-		"\3\2\2\2\u0288\u0287\3\2\2\2\u0289\u028e\3\2\2\2\u028a\u028d\5p9\2\u028b"+
-		"\u028d\5t;\2\u028c\u028a\3\2\2\2\u028c\u028b\3\2\2\2\u028d\u0290\3\2\2"+
-		"\2\u028e\u028c\3\2\2\2\u028e\u028f\3\2\2\2\u028fo\3\2\2\2\u0290\u028e"+
-		"\3\2\2\2\u0291\u0295\7C\2\2\u0292\u0294\5\u00d6l\2\u0293\u0292\3\2\2\2"+
-		"\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296\u0298"+
-		"\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u029a\7h\2\2\u0299\u029b\5(\25\2\u029a"+
-		"\u0299\3\2\2\2\u029a\u029b\3\2\2\2\u029bq\3\2\2\2\u029c\u029e\7h\2\2\u029d"+
-		"\u029f\5(\25\2\u029e\u029d\3\2\2\2\u029e\u029f\3\2\2\2\u029fs\3\2\2\2"+
-		"\u02a0\u02a1\5p9\2\u02a1u\3\2\2\2\u02a2\u02a3\5r:\2\u02a3w\3\2\2\2\u02a4"+
-		"\u02a5\7h\2\2\u02a5y\3\2\2\2\u02a6\u02a7\5j\66\2\u02a7\u02a8\5\36\20\2"+
-		"\u02a8\u02b0\3\2\2\2\u02a9\u02aa\5n8\2\u02aa\u02ab\5\36\20\2\u02ab\u02b0"+
-		"\3\2\2\2\u02ac\u02ad\5x=\2\u02ad\u02ae\5\36\20\2\u02ae\u02b0\3\2\2\2\u02af"+
-		"\u02a6\3\2\2\2\u02af\u02a9\3\2\2\2\u02af\u02ac\3\2\2\2\u02b0{\3\2\2\2"+
-		"\u02b1\u02b3\5~@\2\u02b2\u02b1\3\2\2\2\u02b3\u02b6\3\2\2\2\u02b4\u02b2"+
-		"\3\2\2\2\u02b4\u02b5\3\2\2\2\u02b5\u02b7\3\2\2\2\u02b6\u02b4\3\2\2\2\u02b7"+
-		"\u02b8\5\u0080A\2\u02b8\u02b9\5\u0098M\2\u02b9}\3\2\2\2\u02ba\u02c5\5"+
-		"\u00d6l\2\u02bb\u02c5\7%\2\2\u02bc\u02c5\7$\2\2\u02bd\u02c5\7#\2\2\u02be"+
-		"\u02c5\7\3\2\2\u02bf\u02c5\7(\2\2\u02c0\u02c5\7\24\2\2\u02c1\u02c5\7,"+
-		"\2\2\u02c2\u02c5\7 \2\2\u02c3\u02c5\7)\2\2\u02c4\u02ba\3\2\2\2\u02c4\u02bb"+
-		"\3\2\2\2\u02c4\u02bc\3\2\2\2\u02c4\u02bd\3\2\2\2\u02c4\u02be\3\2\2\2\u02c4"+
-		"\u02bf\3\2\2\2\u02c4\u02c0\3\2\2\2\u02c4\u02c1\3\2\2\2\u02c4\u02c2\3\2"+
-		"\2\2\u02c4\u02c3\3\2\2\2\u02c5\177\3\2\2\2\u02c6\u02c7\5\u0082B\2\u02c7"+
-		"\u02c9\5\u0084C\2\u02c8\u02ca\5\u0092J\2\u02c9\u02c8\3\2\2\2\u02c9\u02ca"+
-		"\3\2\2\2\u02ca\u02d8\3\2\2\2\u02cb\u02cf\5R*\2\u02cc\u02ce\5\u00d6l\2"+
-		"\u02cd\u02cc\3\2\2\2\u02ce\u02d1\3\2\2\2\u02cf\u02cd\3\2\2\2\u02cf\u02d0"+
-		"\3\2\2\2\u02d0\u02d2\3\2\2\2\u02d1\u02cf\3\2\2\2\u02d2\u02d3\5\u0082B"+
-		"\2\u02d3\u02d5\5\u0084C\2\u02d4\u02d6\5\u0092J\2\u02d5\u02d4\3\2\2\2\u02d5"+
-		"\u02d6\3\2\2\2\u02d6\u02d8\3\2\2\2\u02d7\u02c6\3\2\2\2\u02d7\u02cb\3\2"+
-		"\2\2\u02d8\u0081\3\2\2\2\u02d9\u02dc\5h\65\2\u02da\u02dc\7\62\2\2\u02db"+
-		"\u02d9\3\2\2\2\u02db\u02da\3\2\2\2\u02dc\u0083\3\2\2\2\u02dd\u02de\7h"+
-		"\2\2\u02de\u02e0\7;\2\2\u02df\u02e1\5\u0086D\2\u02e0\u02df\3\2\2\2\u02e0"+
-		"\u02e1\3\2\2\2\u02e1\u02e2\3\2\2\2\u02e2\u02e4\7<\2\2\u02e3\u02e5\5\36"+
-		"\20\2\u02e4\u02e3\3\2\2\2\u02e4\u02e5\3\2\2\2\u02e5\u0085\3\2\2\2\u02e6"+
-		"\u02e7\5\u0088E\2\u02e7\u02e8\7B\2\2\u02e8\u02e9\5\u008eH\2\u02e9\u02ec"+
-		"\3\2\2\2\u02ea\u02ec\5\u008eH\2\u02eb\u02e6\3\2\2\2\u02eb\u02ea\3\2\2"+
-		"\2\u02ec\u0087\3\2\2\2\u02ed\u02f2\5\u008aF\2\u02ee\u02ef\7B\2\2\u02ef"+
-		"\u02f1\5\u008aF\2\u02f0\u02ee\3\2\2\2\u02f1\u02f4\3\2\2\2\u02f2\u02f0"+
-		"\3\2\2\2\u02f2\u02f3\3\2\2\2\u02f3\u02fe\3\2\2\2\u02f4\u02f2\3\2\2\2\u02f5"+
-		"\u02fa\5\u0090I\2\u02f6\u02f7\7B\2\2\u02f7\u02f9\5\u008aF\2\u02f8\u02f6"+
-		"\3\2\2\2\u02f9\u02fc\3\2\2\2\u02fa\u02f8\3\2\2\2\u02fa\u02fb\3\2\2\2\u02fb"+
-		"\u02fe\3\2\2\2\u02fc\u02fa\3\2\2\2\u02fd\u02ed\3\2\2\2\u02fd\u02f5\3\2"+
-		"\2\2\u02fe\u0089\3\2\2\2\u02ff\u0301\5\u008cG\2\u0300\u02ff\3\2\2\2\u0301"+
-		"\u0304\3\2\2\2\u0302\u0300\3\2\2\2\u0302\u0303\3\2\2\2\u0303\u0305\3\2"+
-		"\2\2\u0304\u0302\3\2\2\2\u0305\u0306\5h\65\2\u0306\u0307\5d\63\2\u0307"+
-		"\u008b\3\2\2\2\u0308\u030b\5\u00d6l\2\u0309\u030b\7\24\2\2\u030a\u0308"+
-		"\3\2\2\2\u030a\u0309\3\2\2\2\u030b\u008d\3\2\2\2\u030c\u030e\5\u008cG"+
-		"\2\u030d\u030c\3\2\2\2\u030e\u0311\3\2\2\2\u030f\u030d\3\2\2\2\u030f\u0310"+
-		"\3\2\2\2\u0310\u0312\3\2\2\2\u0311\u030f\3\2\2\2\u0312\u0316\5h\65\2\u0313"+
-		"\u0315\5\u00d6l\2\u0314\u0313\3\2\2\2\u0315\u0318\3\2\2\2\u0316\u0314"+
-		"\3\2\2\2\u0316\u0317\3\2\2\2\u0317\u0319\3\2\2\2\u0318\u0316\3\2\2\2\u0319"+
-		"\u031a\7j\2\2\u031a\u031b\5d\63\2\u031b\u031e\3\2\2\2\u031c\u031e\5\u008a"+
-		"F\2\u031d\u030f\3\2\2\2\u031d\u031c\3\2\2\2\u031e\u008f\3\2\2\2\u031f"+
-		"\u0321\5\u00d6l\2\u0320\u031f\3\2\2\2\u0321\u0324\3\2\2\2\u0322\u0320"+
-		"\3\2\2\2\u0322\u0323\3\2\2\2\u0323\u0325\3\2\2\2\u0324\u0322\3\2\2\2\u0325"+
-		"\u0328\5h\65\2\u0326\u0327\7h\2\2\u0327\u0329\7C\2\2\u0328\u0326\3\2\2"+
-		"\2\u0328\u0329\3\2\2\2\u0329\u032a\3\2\2\2\u032a\u032b\7-\2\2\u032b\u0091"+
-		"\3\2\2\2\u032c\u032d\7/\2\2\u032d\u032e\5\u0094K\2\u032e\u0093\3\2\2\2"+
-		"\u032f\u0334\5\u0096L\2\u0330\u0331\7B\2\2\u0331\u0333\5\u0096L\2\u0332"+
-		"\u0330\3\2\2\2\u0333\u0336\3\2\2\2\u0334\u0332\3\2\2\2\u0334\u0335\3\2"+
-		"\2\2\u0335\u0095\3\2\2\2\u0336\u0334\3\2\2\2\u0337\u033a\5\16\b\2\u0338"+
-		"\u033a\5\32\16\2\u0339\u0337\3\2\2\2\u0339\u0338\3\2\2\2\u033a\u0097\3"+
-		"\2\2\2\u033b\u033e\5\u00ecw\2\u033c\u033e\7A\2\2\u033d\u033b\3\2\2\2\u033d"+
-		"\u033c\3\2\2\2\u033e\u0099\3\2\2\2\u033f\u0340\5\u00ecw\2\u0340\u009b"+
-		"\3\2\2\2\u0341\u0342\7(\2\2\u0342\u0343\5\u00ecw\2\u0343\u009d\3\2\2\2"+
-		"\u0344\u0346\5\u00a0Q\2\u0345\u0344\3\2\2\2\u0346\u0349\3\2\2\2\u0347"+
-		"\u0345\3\2\2\2\u0347\u0348\3\2\2\2\u0348\u034a\3\2\2\2\u0349\u0347\3\2"+
-		"\2\2\u034a\u034c\5\u00a2R\2\u034b\u034d\5\u0092J\2\u034c\u034b\3\2\2\2"+
-		"\u034c\u034d\3\2\2\2\u034d\u034e\3\2\2\2\u034e\u034f\5\u00a6T\2\u034f"+
-		"\u009f\3\2\2\2\u0350\u0355\5\u00d6l\2\u0351\u0355\7%\2\2\u0352\u0355\7"+
-		"$\2\2\u0353\u0355\7#\2\2\u0354\u0350\3\2\2\2\u0354\u0351\3\2\2\2\u0354"+
-		"\u0352\3\2\2\2\u0354\u0353\3\2\2\2\u0355\u00a1\3\2\2\2\u0356\u0358\5R"+
-		"*\2\u0357\u0356\3\2\2\2\u0357\u0358\3\2\2\2\u0358\u0359\3\2\2\2\u0359"+
-		"\u035a\5\u00a4S\2\u035a\u035c\7;\2\2\u035b\u035d\5\u0086D\2\u035c\u035b"+
-		"\3\2\2\2\u035c\u035d\3\2\2\2\u035d\u035e\3\2\2\2\u035e\u035f\7<\2\2\u035f"+
-		"\u00a3\3\2\2\2\u0360\u0361\7h\2\2\u0361\u00a5\3\2\2\2\u0362\u0364\7=\2"+
-		"\2\u0363\u0365\5\u00a8U\2\u0364\u0363\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+
-		"\u0367\3\2\2\2\u0366\u0368\5\u00eex\2\u0367\u0366\3\2\2\2\u0367\u0368"+
-		"\3\2\2\2\u0368\u0369\3\2\2\2\u0369\u036a\7>\2\2\u036a\u00a7\3\2\2\2\u036b"+
-		"\u036d\5(\25\2\u036c\u036b\3\2\2\2\u036c\u036d\3\2\2\2\u036d\u036e\3\2"+
-		"\2\2\u036e\u036f\7-\2\2\u036f\u0371\7;\2\2\u0370\u0372\5\u00b6\\\2\u0371"+
-		"\u0370\3\2\2\2\u0371\u0372\3\2\2\2\u0372\u0373\3\2\2\2\u0373\u0374\7<"+
-		"\2\2\u0374\u039a\7A\2\2\u0375\u0377\5(\25\2\u0376\u0375\3\2\2\2\u0376"+
-		"\u0377\3\2\2\2\u0377\u0378\3\2\2\2\u0378\u0379\7*\2\2\u0379\u037b\7;\2"+
-		"\2\u037a\u037c\5\u00b6\\\2\u037b\u037a\3\2\2\2\u037b\u037c\3\2\2\2\u037c"+
-		"\u037d\3\2\2\2\u037d\u037e\7<\2\2\u037e\u039a\7A\2\2\u037f\u0380\5\66"+
-		"\34\2\u0380\u0382\7C\2\2\u0381\u0383\5(\25\2\u0382\u0381\3\2\2\2\u0382"+
-		"\u0383\3\2\2\2\u0383\u0384\3\2\2\2\u0384\u0385\7*\2\2\u0385\u0387\7;\2"+
-		"\2\u0386\u0388\5\u00b6\\\2\u0387\u0386\3\2\2\2\u0387\u0388\3\2\2\2\u0388"+
-		"\u0389\3\2\2\2\u0389\u038a\7<\2\2\u038a\u038b\7A\2\2\u038b\u039a\3\2\2"+
-		"\2\u038c\u038d\5\u00bc_\2\u038d\u038f\7C\2\2\u038e\u0390\5(\25\2\u038f"+
-		"\u038e\3\2\2\2\u038f\u0390\3\2\2\2\u0390\u0391\3\2\2\2\u0391\u0392\7*"+
-		"\2\2\u0392\u0394\7;\2\2\u0393\u0395\5\u00b6\\\2\u0394\u0393\3\2\2\2\u0394"+
-		"\u0395\3\2\2\2\u0395\u0396\3\2\2\2\u0396\u0397\7<\2\2\u0397\u0398\7A\2"+
-		"\2\u0398\u039a\3\2\2\2\u0399\u036c\3\2\2\2\u0399\u0376\3\2\2\2\u0399\u037f"+
-		"\3\2\2\2\u0399\u038c\3\2\2\2\u039a\u00a9\3\2\2\2\u039b\u039d\5P)\2\u039c"+
-		"\u039b\3\2\2\2\u039d\u03a0\3\2\2\2\u039e\u039c\3\2\2\2\u039e\u039f\3\2"+
-		"\2\2\u039f\u03a1\3\2\2\2\u03a0\u039e\3\2\2\2\u03a1\u03a2\7\22\2\2\u03a2"+
-		"\u03a4\7h\2\2\u03a3\u03a5\5X-\2\u03a4\u03a3\3\2\2\2\u03a4\u03a5\3\2\2"+
-		"\2\u03a5\u03a6\3\2\2\2\u03a6\u03a7\5\u00acW\2\u03a7\u00ab\3\2\2\2\u03a8"+
-		"\u03aa\7=\2\2\u03a9\u03ab\5\u00aeX\2\u03aa\u03a9\3\2\2\2\u03aa\u03ab\3"+
-		"\2\2\2\u03ab\u03ad\3\2\2\2\u03ac\u03ae\7B\2\2\u03ad\u03ac\3\2\2\2\u03ad"+
-		"\u03ae\3\2\2\2\u03ae\u03b0\3\2\2\2\u03af\u03b1\5\u00b4[\2\u03b0\u03af"+
-		"\3\2\2\2\u03b0\u03b1\3\2\2\2\u03b1\u03b2\3\2\2\2\u03b2\u03b3\7>\2\2\u03b3"+
-		"\u00ad\3\2\2\2\u03b4\u03b9\5\u00b0Y\2\u03b5\u03b6\7B\2\2\u03b6\u03b8\5"+
-		"\u00b0Y\2\u03b7\u03b5\3\2\2\2\u03b8\u03bb\3\2\2\2\u03b9\u03b7\3\2\2\2"+
-		"\u03b9\u03ba\3\2\2\2\u03ba\u00af\3\2\2\2\u03bb\u03b9\3\2\2\2\u03bc\u03be"+
-		"\5\u00b2Z\2\u03bd\u03bc\3\2\2\2\u03be\u03c1\3\2\2\2\u03bf\u03bd\3\2\2"+
-		"\2\u03bf\u03c0\3\2\2\2\u03c0\u03c2\3\2\2\2\u03c1\u03bf\3\2\2\2\u03c2\u03c8"+
-		"\7h\2\2\u03c3\u03c5\7;\2\2\u03c4\u03c6\5\u00b6\\\2\u03c5\u03c4\3\2\2\2"+
-		"\u03c5\u03c6\3\2\2\2\u03c6\u03c7\3\2\2\2\u03c7\u03c9\7<\2\2\u03c8\u03c3"+
-		"\3\2\2\2\u03c8\u03c9\3\2\2\2\u03c9\u03cb\3\2\2\2\u03ca\u03cc\5\\/\2\u03cb"+
-		"\u03ca\3\2\2\2\u03cb\u03cc\3\2\2\2\u03cc\u00b1\3\2\2\2\u03cd\u03ce\5\u00d6"+
-		"l\2\u03ce\u00b3\3\2\2\2\u03cf\u03d3\7A\2\2\u03d0\u03d2\5^\60\2\u03d1\u03d0"+
-		"\3\2\2\2\u03d2\u03d5\3\2\2\2\u03d3\u03d1\3\2\2\2\u03d3\u03d4\3\2\2\2\u03d4"+
-		"\u00b5\3\2\2\2\u03d5\u03d3\3\2\2\2\u03d6\u03db\5\u00b8]\2\u03d7\u03d8"+
-		"\7B\2\2\u03d8\u03da\5\u00b8]\2\u03d9\u03d7\3\2\2\2\u03da\u03dd\3\2\2\2"+
-		"\u03db\u03d9\3\2\2\2\u03db\u03dc\3\2\2\2\u03dc\u00b7\3\2\2\2\u03dd\u03db"+
-		"\3\2\2\2\u03de\u03e0\13\2\2\2\u03df\u03de\3\2\2\2\u03e0\u03e1\3\2\2\2"+
-		"\u03e1\u03e2\3\2\2\2\u03e1\u03df\3\2\2\2\u03e2\u00b9\3\2\2\2\u03e3\u03e5"+
-		"\13\2\2\2\u03e4\u03e3\3\2\2\2\u03e5\u03e6\3\2\2\2\u03e6\u03e7\3\2\2\2"+
-		"\u03e6\u03e4\3\2\2\2\u03e7\u00bb\3\2\2\2\u03e8\u03ea\13\2\2\2\u03e9\u03e8"+
-		"\3\2\2\2\u03ea\u03eb\3\2\2\2\u03eb\u03ec\3\2\2\2\u03eb\u03e9\3\2\2\2\u03ec"+
-		"\u00bd\3\2\2\2\u03ed\u03f0\5\u00c0a\2\u03ee\u03f0\5\u00d2j\2\u03ef\u03ed"+
-		"\3\2\2\2\u03ef\u03ee\3\2\2\2\u03f0\u00bf\3\2\2\2\u03f1\u03f3\5\u00c2b"+
-		"\2\u03f2\u03f1\3\2\2\2\u03f3\u03f6\3\2\2\2\u03f4\u03f2\3\2\2\2\u03f4\u03f5"+
-		"\3\2\2\2\u03f5\u03f7\3\2\2\2\u03f6\u03f4\3\2\2\2\u03f7\u03f8\7\36\2\2"+
-		"\u03f8\u03fa\7h\2\2\u03f9\u03fb\5R*\2\u03fa\u03f9\3\2\2\2\u03fa\u03fb"+
-		"\3\2\2\2\u03fb\u03fd\3\2\2\2\u03fc\u03fe\5\u00c4c\2\u03fd\u03fc\3\2\2"+
-		"\2\u03fd\u03fe\3\2\2\2\u03fe\u03ff\3\2\2\2\u03ff\u0400\5\u00c6d\2\u0400"+
-		"\u00c1\3\2\2\2\u0401\u0409\5\u00d6l\2\u0402\u0409\7%\2\2\u0403\u0409\7"+
-		"$\2\2\u0404\u0409\7#\2\2\u0405\u0409\7\3\2\2\u0406\u0409\7(\2\2\u0407"+
-		"\u0409\7)\2\2\u0408\u0401\3\2\2\2\u0408\u0402\3\2\2\2\u0408\u0403\3\2"+
-		"\2\2\u0408\u0404\3\2\2\2\u0408\u0405\3\2\2\2\u0408\u0406\3\2\2\2\u0408"+
-		"\u0407\3\2\2\2\u0409\u00c3\3\2\2\2\u040a\u040b\7\23\2\2\u040b\u040c\5"+
-		"Z.\2\u040c\u00c5\3\2\2\2\u040d\u0411\7=\2\2\u040e\u0410\5\u00c8e\2\u040f"+
-		"\u040e\3\2\2\2\u0410\u0413\3\2\2\2\u0411\u040f\3\2\2\2\u0411\u0412\3\2"+
-		"\2\2\u0412\u0414\3\2\2\2\u0413\u0411\3\2\2\2\u0414\u0415\7>\2\2\u0415"+
-		"\u00c7\3\2\2\2\u0416\u041c\5\u00caf\2\u0417\u041c\5\u00ceh\2\u0418\u041c"+
-		"\5L\'\2\u0419\u041c\5\u00be`\2\u041a\u041c\7A\2\2\u041b\u0416\3\2\2\2"+
-		"\u041b\u0417\3\2\2\2\u041b\u0418\3\2\2\2\u041b\u0419\3\2\2\2\u041b\u041a"+
-		"\3\2\2\2\u041c\u00c9\3\2\2\2\u041d\u041f\5\u00ccg\2\u041e\u041d\3\2\2"+
-		"\2\u041f\u0422\3\2\2\2\u0420\u041e\3\2\2\2\u0420\u0421\3\2\2\2\u0421\u0423"+
-		"\3\2\2\2\u0422\u0420\3\2\2\2\u0423\u0425\5h\65\2\u0424\u0426\13\2\2\2"+
-		"\u0425\u0424\3\2\2\2\u0426\u0427\3\2\2\2\u0427\u0428\3\2\2\2\u0427\u0425"+
-		"\3\2\2\2\u0428\u0429\3\2\2\2\u0429\u042a\7A\2\2\u042a\u00cb\3\2\2\2\u042b"+
-		"\u0430\5\u00d6l\2\u042c\u0430\7%\2\2\u042d\u0430\7(\2\2\u042e\u0430\7"+
-		"\24\2\2\u042f\u042b\3\2\2\2\u042f\u042c\3\2\2\2\u042f\u042d\3\2\2\2\u042f"+
-		"\u042e\3\2\2\2\u0430\u00cd\3\2\2\2\u0431\u0433\5\u00d0i\2\u0432\u0431"+
-		"\3\2\2\2\u0433\u0436\3\2\2\2\u0434\u0432\3\2\2\2\u0434\u0435\3\2\2\2\u0435"+
-		"\u0437\3\2\2\2\u0436\u0434\3\2\2\2\u0437\u0438\5\u0080A\2\u0438\u0439"+
-		"\5\u0098M\2\u0439\u00cf\3\2\2\2\u043a\u0441\5\u00d6l\2\u043b\u0441\7%"+
-		"\2\2\u043c\u0441\7\3\2\2\u043d\u0441\7\16\2\2\u043e\u0441\7(\2\2\u043f"+
-		"\u0441\7)\2\2\u0440\u043a\3\2\2\2\u0440\u043b\3\2\2\2\u0440\u043c\3\2"+
-		"\2\2\u0440\u043d\3\2\2\2\u0440\u043e\3\2\2\2\u0440\u043f\3\2\2\2\u0441"+
-		"\u00d1\3\2\2\2\u0442\u0444\5\u00c2b\2\u0443\u0442\3\2\2\2\u0444\u0447"+
-		"\3\2\2\2\u0445\u0443\3\2\2\2\u0445\u0446\3\2\2\2\u0446\u0448\3\2\2\2\u0447"+
-		"\u0445\3\2\2\2\u0448\u0449\7i\2\2\u0449\u044a\7\36\2\2\u044a\u044b\7h"+
-		"\2\2\u044b\u044c\5\u00d4k\2\u044c\u00d3\3\2\2\2\u044d\u044f\7=\2\2\u044e"+
-		"\u0450\13\2\2\2\u044f\u044e\3\2\2\2\u0450\u0451\3\2\2\2\u0451\u0452\3"+
-		"\2\2\2\u0451\u044f\3\2\2\2\u0452\u0453\3\2\2\2\u0453\u0454\7>\2\2\u0454"+
-		"\u00d5\3\2\2\2\u0455\u0459\5\u00d8m\2\u0456\u0459\5\u00e4s\2\u0457\u0459"+
-		"\5\u00e6t\2\u0458\u0455\3\2\2\2\u0458\u0456\3\2\2\2\u0458\u0457\3\2\2"+
-		"\2\u0459\u00d7\3\2\2\2\u045a\u045b\7i\2\2\u045b\u045c\5\62\32\2\u045c"+
-		"\u045e\7;\2\2\u045d\u045f\5\u00dan\2\u045e\u045d\3\2\2\2\u045e\u045f\3"+
-		"\2\2\2\u045f\u0460\3\2\2\2\u0460\u0461\7<\2\2\u0461\u00d9\3\2\2\2\u0462"+
-		"\u0467\5\u00dco\2\u0463\u0464\7B\2\2\u0464\u0466\5\u00dco\2\u0465\u0463"+
-		"\3\2\2\2\u0466\u0469\3\2\2\2\u0467\u0465\3\2\2\2\u0467\u0468\3\2\2\2\u0468"+
-		"\u00db\3\2\2\2\u0469\u0467\3\2\2\2\u046a\u046b\7h\2\2\u046b\u046c\7D\2"+
-		"\2\u046c\u046d\5\u00dep\2\u046d\u00dd\3\2\2\2\u046e\u0472\5\u00ba^\2\u046f"+
-		"\u0472\5\u00e0q\2\u0470\u0472\5\u00d6l\2\u0471\u046e\3\2\2\2\u0471\u046f"+
-		"\3\2\2\2\u0471\u0470\3\2\2\2\u0472\u00df\3\2\2\2\u0473\u0475\7=\2\2\u0474"+
-		"\u0476\5\u00e2r\2\u0475\u0474\3\2\2\2\u0475\u0476\3\2\2\2\u0476\u0478"+
-		"\3\2\2\2\u0477\u0479\7B\2\2\u0478\u0477\3\2\2\2\u0478\u0479\3\2\2\2\u0479"+
-		"\u047a\3\2\2\2\u047a\u047b\7>\2\2\u047b\u00e1\3\2\2\2\u047c\u0481\5\u00de"+
-		"p\2\u047d\u047e\7B\2\2\u047e\u0480\5\u00dep\2\u047f\u047d\3\2\2\2\u0480"+
-		"\u0483\3\2\2\2\u0481\u047f\3\2\2\2\u0481\u0482\3\2\2\2\u0482\u00e3\3\2"+
-		"\2\2\u0483\u0481\3\2\2\2\u0484\u0485\7i\2\2\u0485\u0486\5\62\32\2\u0486"+
-		"\u00e5\3\2\2\2\u0487\u0488\7i\2\2\u0488\u0489\5\62\32\2\u0489\u048a\7"+
-		";\2\2\u048a\u048b\5\u00dep\2\u048b\u048c\7<\2\2\u048c\u00e7\3\2\2\2\u048d"+
-		"\u048f\7=\2\2\u048e\u0490\5\u00eav\2\u048f\u048e\3\2\2\2\u048f\u0490\3"+
-		"\2\2\2\u0490\u0492\3\2\2\2\u0491\u0493\7B\2\2\u0492\u0491\3\2\2\2\u0492"+
-		"\u0493\3\2\2\2\u0493\u0494\3\2\2\2\u0494\u0495\7>\2\2\u0495\u00e9\3\2"+
-		"\2\2\u0496\u049b\5f\64\2\u0497\u0498\7B\2\2\u0498\u049a\5f\64\2\u0499"+
-		"\u0497\3\2\2\2\u049a\u049d\3\2\2\2\u049b\u0499\3\2\2\2\u049b\u049c\3\2"+
-		"\2\2\u049c\u00eb\3\2\2\2\u049d\u049b\3\2\2\2\u049e\u04a0\7=\2\2\u049f"+
-		"\u04a1\5\u00eex\2\u04a0\u049f\3\2\2\2\u04a0\u04a1\3\2\2\2\u04a1\u04a2"+
-		"\3\2\2\2\u04a2\u04a3\7>\2\2\u04a3\u00ed\3\2\2\2\u04a4\u04a6\13\2\2\2\u04a5"+
-		"\u04a4\3\2\2\2\u04a6\u04a7\3\2\2\2\u04a7\u04a8\3\2\2\2\u04a7\u04a5\3\2"+
-		"\2\2\u04a8\u00ef\3\2\2\2\u0094\u00f3\u00fa\u00fe\u0102\u010b\u010f\u0113"+
-		"\u0115\u011b\u0120\u0127\u012c\u012e\u0134\u0139\u013e\u0143\u014e\u015c"+
-		"\u0161\u0169\u0170\u0176\u017b\u0186\u0189\u0197\u019c\u01a1\u01a6\u01ac"+
-		"\u01b3\u01bd\u01c5\u01cf\u01d3\u01d8\u01de\u01e6\u01ef\u01fa\u0217\u021b"+
-		"\u0220\u0226\u0229\u022c\u0238\u0243\u0251\u0258\u0261\u0268\u026d\u0273"+
-		"\u0277\u027b\u027f\u0284\u0288\u028c\u028e\u0295\u029a\u029e\u02af\u02b4"+
-		"\u02c4\u02c9\u02cf\u02d5\u02d7\u02db\u02e0\u02e4\u02eb\u02f2\u02fa\u02fd"+
-		"\u0302\u030a\u030f\u0316\u031d\u0322\u0328\u0334\u0339\u033d\u0347\u034c"+
-		"\u0354\u0357\u035c\u0364\u0367\u036c\u0371\u0376\u037b\u0382\u0387\u038f"+
-		"\u0394\u0399\u039e\u03a4\u03aa\u03ad\u03b0\u03b9\u03bf\u03c5\u03c8\u03cb"+
-		"\u03d3\u03db\u03e1\u03e6\u03eb\u03ef\u03f4\u03fa\u03fd\u0408\u0411\u041b"+
-		"\u0420\u0427\u042f\u0434\u0440\u0445\u0451\u0458\u045e\u0467\u0471\u0475"+
-		"\u0478\u0481\u048f\u0492\u049b\u04a0\u04a7";
+		"w\tw\3\2\7\2\u00f0\n\2\f\2\16\2\u00f3\13\2\3\2\3\2\7\2\u00f7\n\2\f\2\16"+
+		"\2\u00fa\13\2\3\2\5\2\u00fd\n\2\3\3\3\3\5\3\u0101\n\3\3\4\3\4\3\5\3\5"+
+		"\3\6\3\6\3\6\5\6\u010a\n\6\3\7\3\7\5\7\u010e\n\7\3\7\3\7\7\7\u0112\n\7"+
+		"\f\7\16\7\u0115\13\7\3\b\7\b\u0118\n\b\f\b\16\b\u011b\13\b\3\b\3\b\5\b"+
+		"\u011f\n\b\3\b\3\b\3\b\7\b\u0124\n\b\f\b\16\b\u0127\13\b\3\b\3\b\5\b\u012b"+
+		"\n\b\5\b\u012d\n\b\3\t\3\t\7\t\u0131\n\t\f\t\16\t\u0134\13\t\3\t\3\t\5"+
+		"\t\u0138\n\t\3\n\7\n\u013b\n\n\f\n\16\n\u013e\13\n\3\n\3\n\5\n\u0142\n"+
+		"\n\3\13\3\13\3\f\3\f\3\r\3\r\3\16\7\16\u014b\n\16\f\16\16\16\u014e\13"+
+		"\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\5\17\u015b"+
+		"\n\17\3\20\7\20\u015e\n\20\f\20\16\20\u0161\13\20\3\20\3\20\3\20\7\20"+
+		"\u0166\n\20\f\20\16\20\u0169\13\20\3\20\3\20\7\20\u016d\n\20\f\20\16\20"+
+		"\u0170\13\20\3\21\7\21\u0173\n\21\f\21\16\21\u0176\13\21\3\21\3\21\5\21"+
+		"\u017a\n\21\3\22\3\22\3\23\3\23\3\23\3\23\3\23\7\23\u0183\n\23\f\23\16"+
+		"\23\u0186\13\23\5\23\u0188\n\23\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\26"+
+		"\3\26\3\26\7\26\u0194\n\26\f\26\16\26\u0197\13\26\3\27\3\27\5\27\u019b"+
+		"\n\27\3\30\7\30\u019e\n\30\f\30\16\30\u01a1\13\30\3\30\3\30\5\30\u01a5"+
+		"\n\30\3\31\3\31\3\31\3\31\5\31\u01ab\n\31\3\32\3\32\3\32\3\32\3\32\5\32"+
+		"\u01b2\n\32\3\33\3\33\3\33\3\33\3\33\3\33\7\33\u01ba\n\33\f\33\16\33\u01bd"+
+		"\13\33\3\34\5\34\u01c0\n\34\3\34\7\34\u01c3\n\34\f\34\16\34\u01c6\13\34"+
+		"\3\34\7\34\u01c9\n\34\f\34\16\34\u01cc\13\34\3\34\3\34\3\35\7\35\u01d1"+
+		"\n\35\f\35\16\35\u01d4\13\35\3\35\3\35\3\35\3\35\7\35\u01da\n\35\f\35"+
+		"\16\35\u01dd\13\35\3\35\3\35\3\36\3\36\3\37\3\37\3\37\3\37\5\37\u01e7"+
+		"\n\37\3 \3 \3 \3 \3!\3!\3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3#\3#"+
+		"\3#\3#\3#\3#\3#\3$\3$\3$\5$\u0204\n$\3%\3%\5%\u0208\n%\3&\7&\u020b\n&"+
+		"\f&\16&\u020e\13&\3&\3&\3&\5&\u0213\n&\3&\5&\u0216\n&\3&\5&\u0219\n&\3"+
+		"&\3&\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\5\'\u0225\n\'\3(\3(\3(\3(\3)\3)\3"+
+		")\7)\u022e\n)\f)\16)\u0231\13)\3*\3*\3*\3+\3+\3+\3,\3,\3,\7,\u023c\n,"+
+		"\f,\16,\u023f\13,\3-\3-\7-\u0243\n-\f-\16-\u0246\13-\3-\3-\3.\3.\3.\3"+
+		".\5.\u024e\n.\3/\3/\3/\3/\3/\5/\u0255\n/\3\60\7\60\u0258\n\60\f\60\16"+
+		"\60\u025b\13\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3\61\3\61"+
+		"\3\61\5\61\u0269\n\61\3\62\3\62\3\62\7\62\u026e\n\62\f\62\16\62\u0271"+
+		"\13\62\3\63\3\63\3\63\5\63\u0276\n\63\3\64\3\64\5\64\u027a\n\64\3\65\3"+
+		"\65\5\65\u027e\n\65\3\66\3\66\5\66\u0282\n\66\3\67\3\67\5\67\u0286\n\67"+
+		"\38\38\38\58\u028b\n8\39\39\59\u028f\n9\39\39\79\u0293\n9\f9\169\u0296"+
+		"\139\3:\3:\7:\u029a\n:\f:\16:\u029d\13:\3:\3:\5:\u02a1\n:\3;\3;\5;\u02a5"+
+		"\n;\3<\3<\3=\3=\3>\3>\3?\3?\3?\3?\3?\3?\3?\3?\3?\5?\u02b6\n?\3@\7@\u02b9"+
+		"\n@\f@\16@\u02bc\13@\3@\3@\3@\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\5A\u02cb\n"+
+		"A\3B\3B\3B\5B\u02d0\nB\3B\3B\7B\u02d4\nB\fB\16B\u02d7\13B\3B\3B\3B\5B"+
+		"\u02dc\nB\5B\u02de\nB\3C\3C\5C\u02e2\nC\3D\3D\3D\5D\u02e7\nD\3D\3D\5D"+
+		"\u02eb\nD\3E\3E\3E\3E\3E\5E\u02f2\nE\3F\3F\3F\7F\u02f7\nF\fF\16F\u02fa"+
+		"\13F\3F\3F\3F\7F\u02ff\nF\fF\16F\u0302\13F\5F\u0304\nF\3G\7G\u0307\nG"+
+		"\fG\16G\u030a\13G\3G\3G\3G\3H\3H\5H\u0311\nH\3I\7I\u0314\nI\fI\16I\u0317"+
+		"\13I\3I\3I\7I\u031b\nI\fI\16I\u031e\13I\3I\3I\3I\3I\5I\u0324\nI\3J\7J"+
+		"\u0327\nJ\fJ\16J\u032a\13J\3J\3J\3J\5J\u032f\nJ\3J\3J\3K\3K\3K\3L\3L\3"+
+		"L\7L\u0339\nL\fL\16L\u033c\13L\3M\3M\5M\u0340\nM\3N\3N\5N\u0344\nN\3O"+
+		"\3O\3P\3P\3P\3Q\7Q\u034c\nQ\fQ\16Q\u034f\13Q\3Q\3Q\5Q\u0353\nQ\3Q\3Q\3"+
+		"R\3R\3R\3R\5R\u035b\nR\3S\5S\u035e\nS\3S\3S\3S\5S\u0363\nS\3S\3S\3T\3"+
+		"T\3U\3U\3U\3U\3V\7V\u036e\nV\fV\16V\u0371\13V\3V\3V\3V\5V\u0376\nV\3V"+
+		"\3V\3W\3W\5W\u037c\nW\3W\5W\u037f\nW\3W\5W\u0382\nW\3W\3W\3X\3X\3X\7X"+
+		"\u0389\nX\fX\16X\u038c\13X\3Y\7Y\u038f\nY\fY\16Y\u0392\13Y\3Y\3Y\3Y\5"+
+		"Y\u0397\nY\3Y\5Y\u039a\nY\3Y\5Y\u039d\nY\3Z\3Z\3[\3[\7[\u03a3\n[\f[\16"+
+		"[\u03a6\13[\3\\\3\\\3\\\7\\\u03ab\n\\\f\\\16\\\u03ae\13\\\3]\6]\u03b1"+
+		"\n]\r]\16]\u03b2\3^\6^\u03b6\n^\r^\16^\u03b7\3_\3_\5_\u03bc\n_\3`\7`\u03bf"+
+		"\n`\f`\16`\u03c2\13`\3`\3`\3`\5`\u03c7\n`\3`\5`\u03ca\n`\3`\3`\3a\3a\3"+
+		"a\3a\3a\3a\3a\5a\u03d5\na\3b\3b\3b\3c\3c\7c\u03dc\nc\fc\16c\u03df\13c"+
+		"\3c\3c\3d\3d\3d\3d\3d\5d\u03e8\nd\3e\7e\u03eb\ne\fe\16e\u03ee\13e\3e\3"+
+		"e\6e\u03f2\ne\re\16e\u03f3\3e\3e\3f\3f\3f\3f\5f\u03fc\nf\3g\7g\u03ff\n"+
+		"g\fg\16g\u0402\13g\3g\3g\3g\3h\3h\3h\3h\3h\3h\5h\u040d\nh\3i\7i\u0410"+
+		"\ni\fi\16i\u0413\13i\3i\3i\3i\3i\3i\3j\3j\6j\u041c\nj\rj\16j\u041d\3j"+
+		"\3j\3k\3k\3k\5k\u0425\nk\3l\3l\3l\3l\5l\u042b\nl\3l\3l\3m\3m\3m\7m\u0432"+
+		"\nm\fm\16m\u0435\13m\3n\3n\3n\3n\3o\3o\3o\5o\u043e\no\3p\3p\5p\u0442\n"+
+		"p\3p\5p\u0445\np\3p\3p\3q\3q\3q\7q\u044c\nq\fq\16q\u044f\13q\3r\3r\3r"+
+		"\3s\3s\3s\3s\3s\3s\3t\3t\5t\u045c\nt\3t\5t\u045f\nt\3t\3t\3u\3u\3u\7u"+
+		"\u0466\nu\fu\16u\u0469\13u\3v\3v\3v\3v\3w\7w\u0470\nw\fw\16w\u0473\13"+
+		"w\3w\7\u03b2\u03b7\u03f3\u041d\u0471\3\64x\2\4\6\b\n\f\16\20\22\24\26"+
+		"\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|"+
+		"~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096"+
+		"\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae"+
+		"\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6"+
+		"\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de"+
+		"\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\2\4\7\2\7\7\n\n\35\35\37\37"+
+		"\'\'\4\2\20\20\26\26\u04b6\2\u00fc\3\2\2\2\4\u0100\3\2\2\2\6\u0102\3\2"+
+		"\2\2\b\u0104\3\2\2\2\n\u0109\3\2\2\2\f\u010d\3\2\2\2\16\u012c\3\2\2\2"+
+		"\20\u012e\3\2\2\2\22\u013c\3\2\2\2\24\u0143\3\2\2\2\26\u0145\3\2\2\2\30"+
+		"\u0147\3\2\2\2\32\u014c\3\2\2\2\34\u015a\3\2\2\2\36\u015f\3\2\2\2 \u0174"+
+		"\3\2\2\2\"\u017b\3\2\2\2$\u0187\3\2\2\2&\u0189\3\2\2\2(\u018c\3\2\2\2"+
+		"*\u0190\3\2\2\2,\u019a\3\2\2\2.\u019f\3\2\2\2\60\u01aa\3\2\2\2\62\u01b1"+
+		"\3\2\2\2\64\u01b3\3\2\2\2\66\u01bf\3\2\2\28\u01d2\3\2\2\2:\u01e0\3\2\2"+
+		"\2<\u01e6\3\2\2\2>\u01e8\3\2\2\2@\u01ec\3\2\2\2B\u01f2\3\2\2\2D\u01f9"+
+		"\3\2\2\2F\u0203\3\2\2\2H\u0207\3\2\2\2J\u020c\3\2\2\2L\u0224\3\2\2\2N"+
+		"\u0226\3\2\2\2P\u022a\3\2\2\2R\u0232\3\2\2\2T\u0235\3\2\2\2V\u0238\3\2"+
+		"\2\2X\u0240\3\2\2\2Z\u024d\3\2\2\2\\\u0254\3\2\2\2^\u0259\3\2\2\2`\u0268"+
+		"\3\2\2\2b\u026a\3\2\2\2d\u0272\3\2\2\2f\u0277\3\2\2\2h\u027d\3\2\2\2j"+
+		"\u0281\3\2\2\2l\u0285\3\2\2\2n\u028a\3\2\2\2p\u028e\3\2\2\2r\u0297\3\2"+
+		"\2\2t\u02a2\3\2\2\2v\u02a6\3\2\2\2x\u02a8\3\2\2\2z\u02aa\3\2\2\2|\u02b5"+
+		"\3\2\2\2~\u02ba\3\2\2\2\u0080\u02ca\3\2\2\2\u0082\u02dd\3\2\2\2\u0084"+
+		"\u02e1\3\2\2\2\u0086\u02e3\3\2\2\2\u0088\u02f1\3\2\2\2\u008a\u0303\3\2"+
+		"\2\2\u008c\u0308\3\2\2\2\u008e\u0310\3\2\2\2\u0090\u0323\3\2\2\2\u0092"+
+		"\u0328\3\2\2\2\u0094\u0332\3\2\2\2\u0096\u0335\3\2\2\2\u0098\u033f\3\2"+
+		"\2\2\u009a\u0343\3\2\2\2\u009c\u0345\3\2\2\2\u009e\u0347\3\2\2\2\u00a0"+
+		"\u034d\3\2\2\2\u00a2\u035a\3\2\2\2\u00a4\u035d\3\2\2\2\u00a6\u0366\3\2"+
+		"\2\2\u00a8\u0368\3\2\2\2\u00aa\u036f\3\2\2\2\u00ac\u0379\3\2\2\2\u00ae"+
+		"\u0385\3\2\2\2\u00b0\u0390\3\2\2\2\u00b2\u039e\3\2\2\2\u00b4\u03a0\3\2"+
+		"\2\2\u00b6\u03a7\3\2\2\2\u00b8\u03b0\3\2\2\2\u00ba\u03b5\3\2\2\2\u00bc"+
+		"\u03bb\3\2\2\2\u00be\u03c0\3\2\2\2\u00c0\u03d4\3\2\2\2\u00c2\u03d6\3\2"+
+		"\2\2\u00c4\u03d9\3\2\2\2\u00c6\u03e7\3\2\2\2\u00c8\u03ec\3\2\2\2\u00ca"+
+		"\u03fb\3\2\2\2\u00cc\u0400\3\2\2\2\u00ce\u040c\3\2\2\2\u00d0\u0411\3\2"+
+		"\2\2\u00d2\u0419\3\2\2\2\u00d4\u0424\3\2\2\2\u00d6\u0426\3\2\2\2\u00d8"+
+		"\u042e\3\2\2\2\u00da\u0436\3\2\2\2\u00dc\u043d\3\2\2\2\u00de\u043f\3\2"+
+		"\2\2\u00e0\u0448\3\2\2\2\u00e2\u0450\3\2\2\2\u00e4\u0453\3\2\2\2\u00e6"+
+		"\u0459\3\2\2\2\u00e8\u0462\3\2\2\2\u00ea\u046a\3\2\2\2\u00ec\u0471\3\2"+
+		"\2\2\u00ee\u00f0\5\u00d4k\2\u00ef\u00ee\3\2\2\2\u00f0\u00f3\3\2\2\2\u00f1"+
+		"\u00ef\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2\u00f4\3\2\2\2\u00f3\u00f1\3\2"+
+		"\2\2\u00f4\u00fd\5\4\3\2\u00f5\u00f7\5\u00d4k\2\u00f6\u00f5\3\2\2\2\u00f7"+
+		"\u00fa\3\2\2\2\u00f8\u00f6\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9\u00fb\3\2"+
+		"\2\2\u00fa\u00f8\3\2\2\2\u00fb\u00fd\7\5\2\2\u00fc\u00f1\3\2\2\2\u00fc"+
+		"\u00f8\3\2\2\2\u00fd\3\3\2\2\2\u00fe\u0101\5\6\4\2\u00ff\u0101\5\b\5\2"+
+		"\u0100\u00fe\3\2\2\2\u0100\u00ff\3\2\2\2\u0101\5\3\2\2\2\u0102\u0103\t"+
+		"\2\2\2\u0103\7\3\2\2\2\u0104\u0105\t\3\2\2\u0105\t\3\2\2\2\u0106\u010a"+
+		"\5\f\7\2\u0107\u010a\5\32\16\2\u0108\u010a\5\34\17\2\u0109\u0106\3\2\2"+
+		"\2\u0109\u0107\3\2\2\2\u0109\u0108\3\2\2\2\u010a\13\3\2\2\2\u010b\u010e"+
+		"\5\22\n\2\u010c\u010e\5\30\r\2\u010d\u010b\3\2\2\2\u010d\u010c\3\2\2\2"+
+		"\u010e\u0113\3\2\2\2\u010f\u0112\5\20\t\2\u0110\u0112\5\26\f\2\u0111\u010f"+
+		"\3\2\2\2\u0111\u0110\3\2\2\2\u0112\u0115\3\2\2\2\u0113\u0111\3\2\2\2\u0113"+
+		"\u0114\3\2\2\2\u0114\r\3\2\2\2\u0115\u0113\3\2\2\2\u0116\u0118\5\u00d4"+
+		"k\2\u0117\u0116\3\2\2\2\u0118\u011b\3\2\2\2\u0119\u0117\3\2\2\2\u0119"+
+		"\u011a\3\2\2\2\u011a\u011c\3\2\2\2\u011b\u0119\3\2\2\2\u011c\u011e\7h"+
+		"\2\2\u011d\u011f\5(\25\2\u011e\u011d\3\2\2\2\u011e\u011f\3\2\2\2\u011f"+
+		"\u012d\3\2\2\2\u0120\u0121\5\f\7\2\u0121\u0125\7C\2\2\u0122\u0124\5\u00d4"+
+		"k\2\u0123\u0122\3\2\2\2\u0124\u0127\3\2\2\2\u0125\u0123\3\2\2\2\u0125"+
+		"\u0126\3\2\2\2\u0126\u0128\3\2\2\2\u0127\u0125\3\2\2\2\u0128\u012a\7h"+
+		"\2\2\u0129\u012b\5(\25\2\u012a\u0129\3\2\2\2\u012a\u012b\3\2\2\2\u012b"+
+		"\u012d\3\2\2\2\u012c\u0119\3\2\2\2\u012c\u0120\3\2\2\2\u012d\17\3\2\2"+
+		"\2\u012e\u0132\7C\2\2\u012f\u0131\5\u00d4k\2\u0130\u012f\3\2\2\2\u0131"+
+		"\u0134\3\2\2\2\u0132\u0130\3\2\2\2\u0132\u0133\3\2\2\2\u0133\u0135\3\2"+
+		"\2\2\u0134\u0132\3\2\2\2\u0135\u0137\7h\2\2\u0136\u0138\5(\25\2\u0137"+
+		"\u0136\3\2\2\2\u0137\u0138\3\2\2\2\u0138\21\3\2\2\2\u0139\u013b\5\u00d4"+
+		"k\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c"+
+		"\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0141\7h"+
+		"\2\2\u0140\u0142\5(\25\2\u0141\u0140\3\2\2\2\u0141\u0142\3\2\2\2\u0142"+
+		"\23\3\2\2\2\u0143\u0144\5\16\b\2\u0144\25\3\2\2\2\u0145\u0146\5\20\t\2"+
+		"\u0146\27\3\2\2\2\u0147\u0148\5\22\n\2\u0148\31\3\2\2\2\u0149\u014b\5"+
+		"\u00d4k\2\u014a\u0149\3\2\2\2\u014b\u014e\3\2\2\2\u014c\u014a\3\2\2\2"+
+		"\u014c\u014d\3\2\2\2\u014d\u014f\3\2\2\2\u014e\u014c\3\2\2\2\u014f\u0150"+
+		"\7h\2\2\u0150\33\3\2\2\2\u0151\u0152\5\2\2\2\u0152\u0153\5\36\20\2\u0153"+
+		"\u015b\3\2\2\2\u0154\u0155\5\f\7\2\u0155\u0156\5\36\20\2\u0156\u015b\3"+
+		"\2\2\2\u0157\u0158\5\32\16\2\u0158\u0159\5\36\20\2\u0159\u015b\3\2\2\2"+
+		"\u015a\u0151\3\2\2\2\u015a\u0154\3\2\2\2\u015a\u0157\3\2\2\2\u015b\35"+
+		"\3\2\2\2\u015c\u015e\5\u00d4k\2\u015d\u015c\3\2\2\2\u015e\u0161\3\2\2"+
+		"\2\u015f\u015d\3\2\2\2\u015f\u0160\3\2\2\2\u0160\u0162\3\2\2\2\u0161\u015f"+
+		"\3\2\2\2\u0162\u0163\7?\2\2\u0163\u016e\7@\2\2\u0164\u0166\5\u00d4k\2"+
+		"\u0165\u0164\3\2\2\2\u0166\u0169\3\2\2\2\u0167\u0165\3\2\2\2\u0167\u0168"+
+		"\3\2\2\2\u0168\u016a\3\2\2\2\u0169\u0167\3\2\2\2\u016a\u016b\7?\2\2\u016b"+
+		"\u016d\7@\2\2\u016c\u0167\3\2\2\2\u016d\u0170\3\2\2\2\u016e\u016c\3\2"+
+		"\2\2\u016e\u016f\3\2\2\2\u016f\37\3\2\2\2\u0170\u016e\3\2\2\2\u0171\u0173"+
+		"\5\"\22\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2\2\2"+
+		"\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2\u0177\u0179"+
+		"\7h\2\2\u0178\u017a\5$\23\2\u0179\u0178\3\2\2\2\u0179\u017a\3\2\2\2\u017a"+
+		"!\3\2\2\2\u017b\u017c\5\u00d4k\2\u017c#\3\2\2\2\u017d\u017e\7\23\2\2\u017e"+
+		"\u0188\5\32\16\2\u017f\u0180\7\23\2\2\u0180\u0184\5\f\7\2\u0181\u0183"+
+		"\5&\24\2\u0182\u0181\3\2\2\2\u0183\u0186\3\2\2\2\u0184\u0182\3\2\2\2\u0184"+
+		"\u0185\3\2\2\2\u0185\u0188\3\2\2\2\u0186\u0184\3\2\2\2\u0187\u017d\3\2"+
+		"\2\2\u0187\u017f\3\2\2\2\u0188%\3\2\2\2\u0189\u018a\7W\2\2\u018a\u018b"+
+		"\5\24\13\2\u018b\'\3\2\2\2\u018c\u018d\7F\2\2\u018d\u018e\5*\26\2\u018e"+
+		"\u018f\7E\2\2\u018f)\3\2\2\2\u0190\u0195\5,\27\2\u0191\u0192\7B\2\2\u0192"+
+		"\u0194\5,\27\2\u0193\u0191\3\2\2\2\u0194\u0197\3\2\2\2\u0195\u0193\3\2"+
+		"\2\2\u0195\u0196\3\2\2\2\u0196+\3\2\2\2\u0197\u0195\3\2\2\2\u0198\u019b"+
+		"\5\n\6\2\u0199\u019b\5.\30\2\u019a\u0198\3\2\2\2\u019a\u0199\3\2\2\2\u019b"+
+		"-\3\2\2\2\u019c\u019e\5\u00d4k\2\u019d\u019c\3\2\2\2\u019e\u01a1\3\2\2"+
+		"\2\u019f\u019d\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a2\3\2\2\2\u01a1\u019f"+
+		"\3\2\2\2\u01a2\u01a4\7I\2\2\u01a3\u01a5\5\60\31\2\u01a4\u01a3\3\2\2\2"+
+		"\u01a4\u01a5\3\2\2\2\u01a5/\3\2\2\2\u01a6\u01a7\7\23\2\2\u01a7\u01ab\5"+
+		"\n\6\2\u01a8\u01a9\7*\2\2\u01a9\u01ab\5\n\6\2\u01aa\u01a6\3\2\2\2\u01aa"+
+		"\u01a8\3\2\2\2\u01ab\61\3\2\2\2\u01ac\u01b2\7h\2\2\u01ad\u01ae\5\64\33"+
+		"\2\u01ae\u01af\7C\2\2\u01af\u01b0\7h\2\2\u01b0\u01b2\3\2\2\2\u01b1\u01ac"+
+		"\3\2\2\2\u01b1\u01ad\3\2\2\2\u01b2\63\3\2\2\2\u01b3\u01b4\b\33\1\2\u01b4"+
+		"\u01b5\7h\2\2\u01b5\u01bb\3\2\2\2\u01b6\u01b7\f\3\2\2\u01b7\u01b8\7C\2"+
+		"\2\u01b8\u01ba\7h\2\2\u01b9\u01b6\3\2\2\2\u01ba\u01bd\3\2\2\2\u01bb\u01b9"+
+		"\3\2\2\2\u01bb\u01bc\3\2\2\2\u01bc\65\3\2\2\2\u01bd\u01bb\3\2\2\2\u01be"+
+		"\u01c0\58\35\2\u01bf\u01be\3\2\2\2\u01bf\u01c0\3\2\2\2\u01c0\u01c4\3\2"+
+		"\2\2\u01c1\u01c3\5<\37\2\u01c2\u01c1\3\2\2\2\u01c3\u01c6\3\2\2\2\u01c4"+
+		"\u01c2\3\2\2\2\u01c4\u01c5\3\2\2\2\u01c5\u01ca\3\2\2\2\u01c6\u01c4\3\2"+
+		"\2\2\u01c7\u01c9\5F$\2\u01c8\u01c7\3\2\2\2\u01c9\u01cc\3\2\2\2\u01ca\u01c8"+
+		"\3\2\2\2\u01ca\u01cb\3\2\2\2\u01cb\u01cd\3\2\2\2\u01cc\u01ca\3\2\2\2\u01cd"+
+		"\u01ce\7\2\2\3\u01ce\67\3\2\2\2\u01cf\u01d1\5:\36\2\u01d0\u01cf\3\2\2"+
+		"\2\u01d1\u01d4\3\2\2\2\u01d2\u01d0\3\2\2\2\u01d2\u01d3\3\2\2\2\u01d3\u01d5"+
+		"\3\2\2\2\u01d4\u01d2\3\2\2\2\u01d5\u01d6\7\"\2\2\u01d6\u01db\7h\2\2\u01d7"+
+		"\u01d8\7C\2\2\u01d8\u01da\7h\2\2\u01d9\u01d7\3\2\2\2\u01da\u01dd\3\2\2"+
+		"\2\u01db\u01d9\3\2\2\2\u01db\u01dc\3\2\2\2\u01dc\u01de\3\2\2\2\u01dd\u01db"+
+		"\3\2\2\2\u01de\u01df\7A\2\2\u01df9\3\2\2\2\u01e0\u01e1\5\u00d4k\2\u01e1"+
+		";\3\2\2\2\u01e2\u01e7\5> \2\u01e3\u01e7\5@!\2\u01e4\u01e7\5B\"\2\u01e5"+
+		"\u01e7\5D#\2\u01e6\u01e2\3\2\2\2\u01e6\u01e3\3\2\2\2\u01e6\u01e4\3\2\2"+
+		"\2\u01e6\u01e5\3\2\2\2\u01e7=\3\2\2\2\u01e8\u01e9\7\33\2\2\u01e9\u01ea"+
+		"\5\62\32\2\u01ea\u01eb\7A\2\2\u01eb?\3\2\2\2\u01ec\u01ed\7\33\2\2\u01ed"+
+		"\u01ee\5\64\33\2\u01ee\u01ef\7C\2\2\u01ef\u01f0\7U\2\2\u01f0\u01f1\7A"+
+		"\2\2\u01f1A\3\2\2\2\u01f2\u01f3\7\33\2\2\u01f3\u01f4\7(\2\2\u01f4\u01f5"+
+		"\5\62\32\2\u01f5\u01f6\7C\2\2\u01f6\u01f7\7h\2\2\u01f7\u01f8\7A\2\2\u01f8"+
+		"C\3\2\2\2\u01f9\u01fa\7\33\2\2\u01fa\u01fb\7(\2\2\u01fb\u01fc\5\62\32"+
+		"\2\u01fc\u01fd\7C\2\2\u01fd\u01fe\7U\2\2\u01fe\u01ff\7A\2\2\u01ffE\3\2"+
+		"\2\2\u0200\u0204\5H%\2\u0201\u0204\5\u00bc_\2\u0202\u0204\7A\2\2\u0203"+
+		"\u0200\3\2\2\2\u0203\u0201\3\2\2\2\u0203\u0202\3\2\2\2\u0204G\3\2\2\2"+
+		"\u0205\u0208\5J&\2\u0206\u0208\5\u00aaV\2\u0207\u0205\3\2\2\2\u0207\u0206"+
+		"\3\2\2\2\u0208I\3\2\2\2\u0209\u020b\5L\'\2\u020a\u0209\3\2\2\2\u020b\u020e"+
+		"\3\2\2\2\u020c\u020a\3\2\2\2\u020c\u020d\3\2\2\2\u020d\u020f\3\2\2\2\u020e"+
+		"\u020c\3\2\2\2\u020f\u0210\7\13\2\2\u0210\u0212\7h\2\2\u0211\u0213\5N"+
+		"(\2\u0212\u0211\3\2\2\2\u0212\u0213\3\2\2\2\u0213\u0215\3\2\2\2\u0214"+
+		"\u0216\5R*\2\u0215\u0214\3\2\2\2\u0215\u0216\3\2\2\2\u0216\u0218\3\2\2"+
+		"\2\u0217\u0219\5T+\2\u0218\u0217\3\2\2\2\u0218\u0219\3\2\2\2\u0219\u021a"+
+		"\3\2\2\2\u021a\u021b\5X-\2\u021bK\3\2\2\2\u021c\u0225\5\u00d4k\2\u021d"+
+		"\u0225\7%\2\2\u021e\u0225\7$\2\2\u021f\u0225\7#\2\2\u0220\u0225\7\3\2"+
+		"\2\u0221\u0225\7(\2\2\u0222\u0225\7\24\2\2\u0223\u0225\7)\2\2\u0224\u021c"+
+		"\3\2\2\2\u0224\u021d\3\2\2\2\u0224\u021e\3\2\2\2\u0224\u021f\3\2\2\2\u0224"+
+		"\u0220\3\2\2\2\u0224\u0221\3\2\2\2\u0224\u0222\3\2\2\2\u0224\u0223\3\2"+
+		"\2\2\u0225M\3\2\2\2\u0226\u0227\7F\2\2\u0227\u0228\5P)\2\u0228\u0229\7"+
+		"E\2\2\u0229O\3\2\2\2\u022a\u022f\5 \21\2\u022b\u022c\7B\2\2\u022c\u022e"+
+		"\5 \21\2\u022d\u022b\3\2\2\2\u022e\u0231\3\2\2\2\u022f\u022d\3\2\2\2\u022f"+
+		"\u0230\3\2\2\2\u0230Q\3\2\2\2\u0231\u022f\3\2\2\2\u0232\u0233\7\23\2\2"+
+		"\u0233\u0234\5\16\b\2\u0234S\3\2\2\2\u0235\u0236\7\32\2\2\u0236\u0237"+
+		"\5V,\2\u0237U\3\2\2\2\u0238\u023d\5\24\13\2\u0239\u023a\7B\2\2\u023a\u023c"+
+		"\5\24\13\2\u023b\u0239\3\2\2\2\u023c\u023f\3\2\2\2\u023d\u023b\3\2\2\2"+
+		"\u023d\u023e\3\2\2\2\u023eW\3\2\2\2\u023f\u023d\3\2\2\2\u0240\u0244\7"+
+		"=\2\2\u0241\u0243\5Z.\2\u0242\u0241\3\2\2\2\u0243\u0246\3\2\2\2\u0244"+
+		"\u0242\3\2\2\2\u0244\u0245\3\2\2\2\u0245\u0247\3\2\2\2\u0246\u0244\3\2"+
+		"\2\2\u0247\u0248\7>\2\2\u0248Y\3\2\2\2\u0249\u024e\5\\/\2\u024a\u024e"+
+		"\5\u009cO\2\u024b\u024e\5\u009eP\2\u024c\u024e\5\u00a0Q\2\u024d\u0249"+
+		"\3\2\2\2\u024d\u024a\3\2\2\2\u024d\u024b\3\2\2\2\u024d\u024c\3\2\2\2\u024e"+
+		"[\3\2\2\2\u024f\u0255\5^\60\2\u0250\u0255\5~@\2\u0251\u0255\5H%\2\u0252"+
+		"\u0255\5\u00bc_\2\u0253\u0255\7A\2\2\u0254\u024f\3\2\2\2\u0254\u0250\3"+
+		"\2\2\2\u0254\u0251\3\2\2\2\u0254\u0252\3\2\2\2\u0254\u0253\3\2\2\2\u0255"+
+		"]\3\2\2\2\u0256\u0258\5`\61\2\u0257\u0256\3\2\2\2\u0258\u025b\3\2\2\2"+
+		"\u0259\u0257\3\2\2\2\u0259\u025a\3\2\2\2\u025a\u025c\3\2\2\2\u025b\u0259"+
+		"\3\2\2\2\u025c\u025d\5j\66\2\u025d\u025e\5b\62\2\u025e\u025f\7A\2\2\u025f"+
+		"_\3\2\2\2\u0260\u0269\5\u00d4k\2\u0261\u0269\7%\2\2\u0262\u0269\7$\2\2"+
+		"\u0263\u0269\7#\2\2\u0264\u0269\7(\2\2\u0265\u0269\7\24\2\2\u0266\u0269"+
+		"\7\60\2\2\u0267\u0269\7\63\2\2\u0268\u0260\3\2\2\2\u0268\u0261\3\2\2\2"+
+		"\u0268\u0262\3\2\2\2\u0268\u0263\3\2\2\2\u0268\u0264\3\2\2\2\u0268\u0265"+
+		"\3\2\2\2\u0268\u0266\3\2\2\2\u0268\u0267\3\2\2\2\u0269a\3\2\2\2\u026a"+
+		"\u026f\5d\63\2\u026b\u026c\7B\2\2\u026c\u026e\5d\63\2\u026d\u026b\3\2"+
+		"\2\2\u026e\u0271\3\2\2\2\u026f\u026d\3\2\2\2\u026f\u0270\3\2\2\2\u0270"+
+		"c\3\2\2\2\u0271\u026f\3\2\2\2\u0272\u0275\5f\64\2\u0273\u0274\7D\2\2\u0274"+
+		"\u0276\5h\65\2\u0275\u0273\3\2\2\2\u0275\u0276\3\2\2\2\u0276e\3\2\2\2"+
+		"\u0277\u0279\7h\2\2\u0278\u027a\5\36\20\2\u0279\u0278\3\2\2\2\u0279\u027a"+
+		"\3\2\2\2\u027ag\3\2\2\2\u027b\u027e\5\u00b8]\2\u027c\u027e\5\u00e6t\2"+
+		"\u027d\u027b\3\2\2\2\u027d\u027c\3\2\2\2\u027ei\3\2\2\2\u027f\u0282\5"+
+		"l\67\2\u0280\u0282\5n8\2\u0281\u027f\3\2\2\2\u0281\u0280\3\2\2\2\u0282"+
+		"k\3\2\2\2\u0283\u0286\5\4\3\2\u0284\u0286\7\5\2\2\u0285\u0283\3\2\2\2"+
+		"\u0285\u0284\3\2\2\2\u0286m\3\2\2\2\u0287\u028b\5p9\2\u0288\u028b\5z>"+
+		"\2\u0289\u028b\5|?\2\u028a\u0287\3\2\2\2\u028a\u0288\3\2\2\2\u028a\u0289"+
+		"\3\2\2\2\u028bo\3\2\2\2\u028c\u028f\5t;\2\u028d\u028f\5x=\2\u028e\u028c"+
+		"\3\2\2\2\u028e\u028d\3\2\2\2\u028f\u0294\3\2\2\2\u0290\u0293\5r:\2\u0291"+
+		"\u0293\5v<\2\u0292\u0290\3\2\2\2\u0292\u0291\3\2\2\2\u0293\u0296\3\2\2"+
+		"\2\u0294\u0292\3\2\2\2\u0294\u0295\3\2\2\2\u0295q\3\2\2\2\u0296\u0294"+
+		"\3\2\2\2\u0297\u029b\7C\2\2\u0298\u029a\5\u00d4k\2\u0299\u0298\3\2\2\2"+
+		"\u029a\u029d\3\2\2\2\u029b\u0299\3\2\2\2\u029b\u029c\3\2\2\2\u029c\u029e"+
+		"\3\2\2\2\u029d\u029b\3\2\2\2\u029e\u02a0\7h\2\2\u029f\u02a1\5(\25\2\u02a0"+
+		"\u029f\3\2\2\2\u02a0\u02a1\3\2\2\2\u02a1s\3\2\2\2\u02a2\u02a4\7h\2\2\u02a3"+
+		"\u02a5\5(\25\2\u02a4\u02a3\3\2\2\2\u02a4\u02a5\3\2\2\2\u02a5u\3\2\2\2"+
+		"\u02a6\u02a7\5r:\2\u02a7w\3\2\2\2\u02a8\u02a9\5t;\2\u02a9y\3\2\2\2\u02aa"+
+		"\u02ab\7h\2\2\u02ab{\3\2\2\2\u02ac\u02ad\5l\67\2\u02ad\u02ae\5\36\20\2"+
+		"\u02ae\u02b6\3\2\2\2\u02af\u02b0\5p9\2\u02b0\u02b1\5\36\20\2\u02b1\u02b6"+
+		"\3\2\2\2\u02b2\u02b3\5z>\2\u02b3\u02b4\5\36\20\2\u02b4\u02b6\3\2\2\2\u02b5"+
+		"\u02ac\3\2\2\2\u02b5\u02af\3\2\2\2\u02b5\u02b2\3\2\2\2\u02b6}\3\2\2\2"+
+		"\u02b7\u02b9\5\u0080A\2\u02b8\u02b7\3\2\2\2\u02b9\u02bc\3\2\2\2\u02ba"+
+		"\u02b8\3\2\2\2\u02ba\u02bb\3\2\2\2\u02bb\u02bd\3\2\2\2\u02bc\u02ba\3\2"+
+		"\2\2\u02bd\u02be\5\u0082B\2\u02be\u02bf\5\u009aN\2\u02bf\177\3\2\2\2\u02c0"+
+		"\u02cb\5\u00d4k\2\u02c1\u02cb\7%\2\2\u02c2\u02cb\7$\2\2\u02c3\u02cb\7"+
+		"#\2\2\u02c4\u02cb\7\3\2\2\u02c5\u02cb\7(\2\2\u02c6\u02cb\7\24\2\2\u02c7"+
+		"\u02cb\7,\2\2\u02c8\u02cb\7 \2\2\u02c9\u02cb\7)\2\2\u02ca\u02c0\3\2\2"+
+		"\2\u02ca\u02c1\3\2\2\2\u02ca\u02c2\3\2\2\2\u02ca\u02c3\3\2\2\2\u02ca\u02c4"+
+		"\3\2\2\2\u02ca\u02c5\3\2\2\2\u02ca\u02c6\3\2\2\2\u02ca\u02c7\3\2\2\2\u02ca"+
+		"\u02c8\3\2\2\2\u02ca\u02c9\3\2\2\2\u02cb\u0081\3\2\2\2\u02cc\u02cd\5\u0084"+
+		"C\2\u02cd\u02cf\5\u0086D\2\u02ce\u02d0\5\u0094K\2\u02cf\u02ce\3\2\2\2"+
+		"\u02cf\u02d0\3\2\2\2\u02d0\u02de\3\2\2\2\u02d1\u02d5\5N(\2\u02d2\u02d4"+
+		"\5\u00d4k\2\u02d3\u02d2\3\2\2\2\u02d4\u02d7\3\2\2\2\u02d5\u02d3\3\2\2"+
+		"\2\u02d5\u02d6\3\2\2\2\u02d6\u02d8\3\2\2\2\u02d7\u02d5\3\2\2\2\u02d8\u02d9"+
+		"\5\u0084C\2\u02d9\u02db\5\u0086D\2\u02da\u02dc\5\u0094K\2\u02db\u02da"+
+		"\3\2\2\2\u02db\u02dc\3\2\2\2\u02dc\u02de\3\2\2\2\u02dd\u02cc\3\2\2\2\u02dd"+
+		"\u02d1\3\2\2\2\u02de\u0083\3\2\2\2\u02df\u02e2\5j\66\2\u02e0\u02e2\7\62"+
+		"\2\2\u02e1\u02df\3\2\2\2\u02e1\u02e0\3\2\2\2\u02e2\u0085\3\2\2\2\u02e3"+
+		"\u02e4\7h\2\2\u02e4\u02e6\7;\2\2\u02e5\u02e7\5\u0088E\2\u02e6\u02e5\3"+
+		"\2\2\2\u02e6\u02e7\3\2\2\2\u02e7\u02e8\3\2\2\2\u02e8\u02ea\7<\2\2\u02e9"+
+		"\u02eb\5\36\20\2\u02ea\u02e9\3\2\2\2\u02ea\u02eb\3\2\2\2\u02eb\u0087\3"+
+		"\2\2\2\u02ec\u02ed\5\u008aF\2\u02ed\u02ee\7B\2\2\u02ee\u02ef\5\u0090I"+
+		"\2\u02ef\u02f2\3\2\2\2\u02f0\u02f2\5\u0090I\2\u02f1\u02ec\3\2\2\2\u02f1"+
+		"\u02f0\3\2\2\2\u02f2\u0089\3\2\2\2\u02f3\u02f8\5\u008cG\2\u02f4\u02f5"+
+		"\7B\2\2\u02f5\u02f7\5\u008cG\2\u02f6\u02f4\3\2\2\2\u02f7\u02fa\3\2\2\2"+
+		"\u02f8\u02f6\3\2\2\2\u02f8\u02f9\3\2\2\2\u02f9\u0304\3\2\2\2\u02fa\u02f8"+
+		"\3\2\2\2\u02fb\u0300\5\u0092J\2\u02fc\u02fd\7B\2\2\u02fd\u02ff\5\u008c"+
+		"G\2\u02fe\u02fc\3\2\2\2\u02ff\u0302\3\2\2\2\u0300\u02fe\3\2\2\2\u0300"+
+		"\u0301\3\2\2\2\u0301\u0304\3\2\2\2\u0302\u0300\3\2\2\2\u0303\u02f3\3\2"+
+		"\2\2\u0303\u02fb\3\2\2\2\u0304\u008b\3\2\2\2\u0305\u0307\5\u008eH\2\u0306"+
+		"\u0305\3\2\2\2\u0307\u030a\3\2\2\2\u0308\u0306\3\2\2\2\u0308\u0309\3\2"+
+		"\2\2\u0309\u030b\3\2\2\2\u030a\u0308\3\2\2\2\u030b\u030c\5j\66\2\u030c"+
+		"\u030d\5f\64\2\u030d\u008d\3\2\2\2\u030e\u0311\5\u00d4k\2\u030f\u0311"+
+		"\7\24\2\2\u0310\u030e\3\2\2\2\u0310\u030f\3\2\2\2\u0311\u008f\3\2\2\2"+
+		"\u0312\u0314\5\u008eH\2\u0313\u0312\3\2\2\2\u0314\u0317\3\2\2\2\u0315"+
+		"\u0313\3\2\2\2\u0315\u0316\3\2\2\2\u0316\u0318\3\2\2\2\u0317\u0315\3\2"+
+		"\2\2\u0318\u031c\5j\66\2\u0319\u031b\5\u00d4k\2\u031a\u0319\3\2\2\2\u031b"+
+		"\u031e\3\2\2\2\u031c\u031a\3\2\2\2\u031c\u031d\3\2\2\2\u031d\u031f\3\2"+
+		"\2\2\u031e\u031c\3\2\2\2\u031f\u0320\7j\2\2\u0320\u0321\5f\64\2\u0321"+
+		"\u0324\3\2\2\2\u0322\u0324\5\u008cG\2\u0323\u0315\3\2\2\2\u0323\u0322"+
+		"\3\2\2\2\u0324\u0091\3\2\2\2\u0325\u0327\5\u00d4k\2\u0326\u0325\3\2\2"+
+		"\2\u0327\u032a\3\2\2\2\u0328\u0326\3\2\2\2\u0328\u0329\3\2\2\2\u0329\u032b"+
+		"\3\2\2\2\u032a\u0328\3\2\2\2\u032b\u032e\5j\66\2\u032c\u032d\7h\2\2\u032d"+
+		"\u032f\7C\2\2\u032e\u032c\3\2\2\2\u032e\u032f\3\2\2\2\u032f\u0330\3\2"+
+		"\2\2\u0330\u0331\7-\2\2\u0331\u0093\3\2\2\2\u0332\u0333\7/\2\2\u0333\u0334"+
+		"\5\u0096L\2\u0334\u0095\3\2\2\2\u0335\u033a\5\u0098M\2\u0336\u0337\7B"+
+		"\2\2\u0337\u0339\5\u0098M\2\u0338\u0336\3\2\2\2\u0339\u033c\3\2\2\2\u033a"+
+		"\u0338\3\2\2\2\u033a\u033b\3\2\2\2\u033b\u0097\3\2\2\2\u033c\u033a\3\2"+
+		"\2\2\u033d\u0340\5\16\b\2\u033e\u0340\5\32\16\2\u033f\u033d\3\2\2\2\u033f"+
+		"\u033e\3\2\2\2\u0340\u0099\3\2\2\2\u0341\u0344\5\u00eav\2\u0342\u0344"+
+		"\7A\2\2\u0343\u0341\3\2\2\2\u0343\u0342\3\2\2\2\u0344\u009b\3\2\2\2\u0345"+
+		"\u0346\5\u00eav\2\u0346\u009d\3\2\2\2\u0347\u0348\7(\2\2\u0348\u0349\5"+
+		"\u00eav\2\u0349\u009f\3\2\2\2\u034a\u034c\5\u00a2R\2\u034b\u034a\3\2\2"+
+		"\2\u034c\u034f\3\2\2\2\u034d\u034b\3\2\2\2\u034d\u034e\3\2\2\2\u034e\u0350"+
+		"\3\2\2\2\u034f\u034d\3\2\2\2\u0350\u0352\5\u00a4S\2\u0351\u0353\5\u0094"+
+		"K\2\u0352\u0351\3\2\2\2\u0352\u0353\3\2\2\2\u0353\u0354\3\2\2\2\u0354"+
+		"\u0355\5\u00a8U\2\u0355\u00a1\3\2\2\2\u0356\u035b\5\u00d4k\2\u0357\u035b"+
+		"\7%\2\2\u0358\u035b\7$\2\2\u0359\u035b\7#\2\2\u035a\u0356\3\2\2\2\u035a"+
+		"\u0357\3\2\2\2\u035a\u0358\3\2\2\2\u035a\u0359\3\2\2\2\u035b\u00a3\3\2"+
+		"\2\2\u035c\u035e\5N(\2\u035d\u035c\3\2\2\2\u035d\u035e\3\2\2\2\u035e\u035f"+
+		"\3\2\2\2\u035f\u0360\5\u00a6T\2\u0360\u0362\7;\2\2\u0361\u0363\5\u0088"+
+		"E\2\u0362\u0361\3\2\2\2\u0362\u0363\3\2\2\2\u0363\u0364\3\2\2\2\u0364"+
+		"\u0365\7<\2\2\u0365\u00a5\3\2\2\2\u0366\u0367\7h\2\2\u0367\u00a7\3\2\2"+
+		"\2\u0368\u0369\7=\2\2\u0369\u036a\5\u00ecw\2\u036a\u036b\7>\2\2\u036b"+
+		"\u00a9\3\2\2\2\u036c\u036e\5L\'\2\u036d\u036c\3\2\2\2\u036e\u0371\3\2"+
+		"\2\2\u036f\u036d\3\2\2\2\u036f\u0370\3\2\2\2\u0370\u0372\3\2\2\2\u0371"+
+		"\u036f\3\2\2\2\u0372\u0373\7\22\2\2\u0373\u0375\7h\2\2\u0374\u0376\5T"+
+		"+\2\u0375\u0374\3\2\2\2\u0375\u0376\3\2\2\2\u0376\u0377\3\2\2\2\u0377"+
+		"\u0378\5\u00acW\2\u0378\u00ab\3\2\2\2\u0379\u037b\7=\2\2\u037a\u037c\5"+
+		"\u00aeX\2\u037b\u037a\3\2\2\2\u037b\u037c\3\2\2\2\u037c\u037e\3\2\2\2"+
+		"\u037d\u037f\7B\2\2\u037e\u037d\3\2\2\2\u037e\u037f\3\2\2\2\u037f\u0381"+
+		"\3\2\2\2\u0380\u0382\5\u00b4[\2\u0381\u0380\3\2\2\2\u0381\u0382\3\2\2"+
+		"\2\u0382\u0383\3\2\2\2\u0383\u0384\7>\2\2\u0384\u00ad\3\2\2\2\u0385\u038a"+
+		"\5\u00b0Y\2\u0386\u0387\7B\2\2\u0387\u0389\5\u00b0Y\2\u0388\u0386\3\2"+
+		"\2\2\u0389\u038c\3\2\2\2\u038a\u0388\3\2\2\2\u038a\u038b\3\2\2\2\u038b"+
+		"\u00af\3\2\2\2\u038c\u038a\3\2\2\2\u038d\u038f\5\u00b2Z\2\u038e\u038d"+
+		"\3\2\2\2\u038f\u0392\3\2\2\2\u0390\u038e\3\2\2\2\u0390\u0391\3\2\2\2\u0391"+
+		"\u0393\3\2\2\2\u0392\u0390\3\2\2\2\u0393\u0399\7h\2\2\u0394\u0396\7;\2"+
+		"\2\u0395\u0397\5\u00b6\\\2\u0396\u0395\3\2\2\2\u0396\u0397\3\2\2\2\u0397"+
+		"\u0398\3\2\2\2\u0398\u039a\7<\2\2\u0399\u0394\3\2\2\2\u0399\u039a\3\2"+
+		"\2\2\u039a\u039c\3\2\2\2\u039b\u039d\5X-\2\u039c\u039b\3\2\2\2\u039c\u039d"+
+		"\3\2\2\2\u039d\u00b1\3\2\2\2\u039e\u039f\5\u00d4k\2\u039f\u00b3\3\2\2"+
+		"\2\u03a0\u03a4\7A\2\2\u03a1\u03a3\5Z.\2\u03a2\u03a1\3\2\2\2\u03a3\u03a6"+
+		"\3\2\2\2\u03a4\u03a2\3\2\2\2\u03a4\u03a5\3\2\2\2\u03a5\u00b5\3\2\2\2\u03a6"+
+		"\u03a4\3\2\2\2\u03a7\u03ac\5\u00b8]\2\u03a8\u03a9\7B\2\2\u03a9\u03ab\5"+
+		"\u00b8]\2\u03aa\u03a8\3\2\2\2\u03ab\u03ae\3\2\2\2\u03ac\u03aa\3\2\2\2"+
+		"\u03ac\u03ad\3\2\2\2\u03ad\u00b7\3\2\2\2\u03ae\u03ac\3\2\2\2\u03af\u03b1"+
+		"\13\2\2\2\u03b0\u03af\3\2\2\2\u03b1\u03b2\3\2\2\2\u03b2\u03b3\3\2\2\2"+
+		"\u03b2\u03b0\3\2\2\2\u03b3\u00b9\3\2\2\2\u03b4\u03b6\13\2\2\2\u03b5\u03b4"+
+		"\3\2\2\2\u03b6\u03b7\3\2\2\2\u03b7\u03b8\3\2\2\2\u03b7\u03b5\3\2\2\2\u03b8"+
+		"\u00bb\3\2\2\2\u03b9\u03bc\5\u00be`\2\u03ba\u03bc\5\u00d0i\2\u03bb\u03b9"+
+		"\3\2\2\2\u03bb\u03ba\3\2\2\2\u03bc\u00bd\3\2\2\2\u03bd\u03bf\5\u00c0a"+
+		"\2\u03be\u03bd\3\2\2\2\u03bf\u03c2\3\2\2\2\u03c0\u03be\3\2\2\2\u03c0\u03c1"+
+		"\3\2\2\2\u03c1\u03c3\3\2\2\2\u03c2\u03c0\3\2\2\2\u03c3\u03c4\7\36\2\2"+
+		"\u03c4\u03c6\7h\2\2\u03c5\u03c7\5N(\2\u03c6\u03c5\3\2\2\2\u03c6\u03c7"+
+		"\3\2\2\2\u03c7\u03c9\3\2\2\2\u03c8\u03ca\5\u00c2b\2\u03c9\u03c8\3\2\2"+
+		"\2\u03c9\u03ca\3\2\2\2\u03ca\u03cb\3\2\2\2\u03cb\u03cc\5\u00c4c\2\u03cc"+
+		"\u00bf\3\2\2\2\u03cd\u03d5\5\u00d4k\2\u03ce\u03d5\7%\2\2\u03cf\u03d5\7"+
+		"$\2\2\u03d0\u03d5\7#\2\2\u03d1\u03d5\7\3\2\2\u03d2\u03d5\7(\2\2\u03d3"+
+		"\u03d5\7)\2\2\u03d4\u03cd\3\2\2\2\u03d4\u03ce\3\2\2\2\u03d4\u03cf\3\2"+
+		"\2\2\u03d4\u03d0\3\2\2\2\u03d4\u03d1\3\2\2\2\u03d4\u03d2\3\2\2\2\u03d4"+
+		"\u03d3\3\2\2\2\u03d5\u00c1\3\2\2\2\u03d6\u03d7\7\23\2\2\u03d7\u03d8\5"+
+		"V,\2\u03d8\u00c3\3\2\2\2\u03d9\u03dd\7=\2\2\u03da\u03dc\5\u00c6d\2\u03db"+
+		"\u03da\3\2\2\2\u03dc\u03df\3\2\2\2\u03dd\u03db\3\2\2\2\u03dd\u03de\3\2"+
+		"\2\2\u03de\u03e0\3\2\2\2\u03df\u03dd\3\2\2\2\u03e0\u03e1\7>\2\2\u03e1"+
+		"\u00c5\3\2\2\2\u03e2\u03e8\5\u00c8e\2\u03e3\u03e8\5\u00ccg\2\u03e4\u03e8"+
+		"\5H%\2\u03e5\u03e8\5\u00bc_\2\u03e6\u03e8\7A\2\2\u03e7\u03e2\3\2\2\2\u03e7"+
+		"\u03e3\3\2\2\2\u03e7\u03e4\3\2\2\2\u03e7\u03e5\3\2\2\2\u03e7\u03e6\3\2"+
+		"\2\2\u03e8\u00c7\3\2\2\2\u03e9\u03eb\5\u00caf\2\u03ea\u03e9\3\2\2\2\u03eb"+
+		"\u03ee\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03ed\3\2\2\2\u03ed\u03ef\3\2"+
+		"\2\2\u03ee\u03ec\3\2\2\2\u03ef\u03f1\5j\66\2\u03f0\u03f2\13\2\2\2\u03f1"+
+		"\u03f0\3\2\2\2\u03f2\u03f3\3\2\2\2\u03f3\u03f4\3\2\2\2\u03f3\u03f1\3\2"+
+		"\2\2\u03f4\u03f5\3\2\2\2\u03f5\u03f6\7A\2\2\u03f6\u00c9\3\2\2\2\u03f7"+
+		"\u03fc\5\u00d4k\2\u03f8\u03fc\7%\2\2\u03f9\u03fc\7(\2\2\u03fa\u03fc\7"+
+		"\24\2\2\u03fb\u03f7\3\2\2\2\u03fb\u03f8\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fb"+
+		"\u03fa\3\2\2\2\u03fc\u00cb\3\2\2\2\u03fd\u03ff\5\u00ceh\2\u03fe\u03fd"+
+		"\3\2\2\2\u03ff\u0402\3\2\2\2\u0400\u03fe\3\2\2\2\u0400\u0401\3\2\2\2\u0401"+
+		"\u0403\3\2\2\2\u0402\u0400\3\2\2\2\u0403\u0404\5\u0082B\2\u0404\u0405"+
+		"\5\u009aN\2\u0405\u00cd\3\2\2\2\u0406\u040d\5\u00d4k\2\u0407\u040d\7%"+
+		"\2\2\u0408\u040d\7\3\2\2\u0409\u040d\7\16\2\2\u040a\u040d\7(\2\2\u040b"+
+		"\u040d\7)\2\2\u040c\u0406\3\2\2\2\u040c\u0407\3\2\2\2\u040c\u0408\3\2"+
+		"\2\2\u040c\u0409\3\2\2\2\u040c\u040a\3\2\2\2\u040c\u040b\3\2\2\2\u040d"+
+		"\u00cf\3\2\2\2\u040e\u0410\5\u00c0a\2\u040f\u040e\3\2\2\2\u0410\u0413"+
+		"\3\2\2\2\u0411\u040f\3\2\2\2\u0411\u0412\3\2\2\2\u0412\u0414\3\2\2\2\u0413"+
+		"\u0411\3\2\2\2\u0414\u0415\7i\2\2\u0415\u0416\7\36\2\2\u0416\u0417\7h"+
+		"\2\2\u0417\u0418\5\u00d2j\2\u0418\u00d1\3\2\2\2\u0419\u041b\7=\2\2\u041a"+
+		"\u041c\13\2\2\2\u041b\u041a\3\2\2\2\u041c\u041d\3\2\2\2\u041d\u041e\3"+
+		"\2\2\2\u041d\u041b\3\2\2\2\u041e\u041f\3\2\2\2\u041f\u0420\7>\2\2\u0420"+
+		"\u00d3\3\2\2\2\u0421\u0425\5\u00d6l\2\u0422\u0425\5\u00e2r\2\u0423\u0425"+
+		"\5\u00e4s\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424\u0423\3\2\2"+
+		"\2\u0425\u00d5\3\2\2\2\u0426\u0427\7i\2\2\u0427\u0428\5\62\32\2\u0428"+
+		"\u042a\7;\2\2\u0429\u042b\5\u00d8m\2\u042a\u0429\3\2\2\2\u042a\u042b\3"+
+		"\2\2\2\u042b\u042c\3\2\2\2\u042c\u042d\7<\2\2\u042d\u00d7\3\2\2\2\u042e"+
+		"\u0433\5\u00dan\2\u042f\u0430\7B\2\2\u0430\u0432\5\u00dan\2\u0431\u042f"+
+		"\3\2\2\2\u0432\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434"+
+		"\u00d9\3\2\2\2\u0435\u0433\3\2\2\2\u0436\u0437\7h\2\2\u0437\u0438\7D\2"+
+		"\2\u0438\u0439\5\u00dco\2\u0439\u00db\3\2\2\2\u043a\u043e\5\u00ba^\2\u043b"+
+		"\u043e\5\u00dep\2\u043c\u043e\5\u00d4k\2\u043d\u043a\3\2\2\2\u043d\u043b"+
+		"\3\2\2\2\u043d\u043c\3\2\2\2\u043e\u00dd\3\2\2\2\u043f\u0441\7=\2\2\u0440"+
+		"\u0442\5\u00e0q\2\u0441\u0440\3\2\2\2\u0441\u0442\3\2\2\2\u0442\u0444"+
+		"\3\2\2\2\u0443\u0445\7B\2\2\u0444\u0443\3\2\2\2\u0444\u0445\3\2\2\2\u0445"+
+		"\u0446\3\2\2\2\u0446\u0447\7>\2\2\u0447\u00df\3\2\2\2\u0448\u044d\5\u00dc"+
+		"o\2\u0449\u044a\7B\2\2\u044a\u044c\5\u00dco\2\u044b\u0449\3\2\2\2\u044c"+
+		"\u044f\3\2\2\2\u044d\u044b\3\2\2\2\u044d\u044e\3\2\2\2\u044e\u00e1\3\2"+
+		"\2\2\u044f\u044d\3\2\2\2\u0450\u0451\7i\2\2\u0451\u0452\5\62\32\2\u0452"+
+		"\u00e3\3\2\2\2\u0453\u0454\7i\2\2\u0454\u0455\5\62\32\2\u0455\u0456\7"+
+		";\2\2\u0456\u0457\5\u00dco\2\u0457\u0458\7<\2\2\u0458\u00e5\3\2\2\2\u0459"+
+		"\u045b\7=\2\2\u045a\u045c\5\u00e8u\2\u045b\u045a\3\2\2\2\u045b\u045c\3"+
+		"\2\2\2\u045c\u045e\3\2\2\2\u045d\u045f\7B\2\2\u045e\u045d\3\2\2\2\u045e"+
+		"\u045f\3\2\2\2\u045f\u0460\3\2\2\2\u0460\u0461\7>\2\2\u0461\u00e7\3\2"+
+		"\2\2\u0462\u0467\5h\65\2\u0463\u0464\7B\2\2\u0464\u0466\5h\65\2\u0465"+
+		"\u0463\3\2\2\2\u0466\u0469\3\2\2\2\u0467\u0465\3\2\2\2\u0467\u0468\3\2"+
+		"\2\2\u0468\u00e9\3\2\2\2\u0469\u0467\3\2\2\2\u046a\u046b\7=\2\2\u046b"+
+		"\u046c\5\u00ecw\2\u046c\u046d\7>\2\2\u046d\u00eb\3\2\2\2\u046e\u0470\13"+
+		"\2\2\2\u046f\u046e\3\2\2\2\u0470\u0473\3\2\2\2\u0471\u0472\3\2\2\2\u0471"+
+		"\u046f\3\2\2\2\u0472\u00ed\3\2\2\2\u0473\u0471\3\2\2\2\u0088\u00f1\u00f8"+
+		"\u00fc\u0100\u0109\u010d\u0111\u0113\u0119\u011e\u0125\u012a\u012c\u0132"+
+		"\u0137\u013c\u0141\u014c\u015a\u015f\u0167\u016e\u0174\u0179\u0184\u0187"+
+		"\u0195\u019a\u019f\u01a4\u01aa\u01b1\u01bb\u01bf\u01c4\u01ca\u01d2\u01db"+
+		"\u01e6\u0203\u0207\u020c\u0212\u0215\u0218\u0224\u022f\u023d\u0244\u024d"+
+		"\u0254\u0259\u0268\u026f\u0275\u0279\u027d\u0281\u0285\u028a\u028e\u0292"+
+		"\u0294\u029b\u02a0\u02a4\u02b5\u02ba\u02ca\u02cf\u02d5\u02db\u02dd\u02e1"+
+		"\u02e6\u02ea\u02f1\u02f8\u0300\u0303\u0308\u0310\u0315\u031c\u0323\u0328"+
+		"\u032e\u033a\u033f\u0343\u034d\u0352\u035a\u035d\u0362\u036f\u0375\u037b"+
+		"\u037e\u0381\u038a\u0390\u0396\u0399\u039c\u03a4\u03ac\u03b2\u03b7\u03bb"+
+		"\u03c0\u03c6\u03c9\u03d4\u03dd\u03e7\u03ec\u03f3\u03fb\u0400\u040c\u0411"+
+		"\u041d\u0424\u042a\u0433\u043d\u0441\u0444\u044d\u045b\u045e\u0467\u0471";
 	public static final ATN _ATN =
 		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
 	static {
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaVisitor.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaVisitor.java
new file mode 100644
index 0000000..5d2e008
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaVisitor.java
@@ -0,0 +1,725 @@
+// Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\DroppingJava.g4 by ANTLR 4.5.1
+package ru.ftc.upc.testing.dropper.lang.gen;
+import org.antlr.v4.runtime.tree.ParseTreeVisitor;
+
+/**
+ * This interface defines a complete generic visitor for a parse tree produced
+ * by {@link DroppingJavaParser}.
+ *
+ * @param <T> The return type of the visit operation. Use {@link Void} for
+ * operations with no return type.
+ */
+public interface DroppingJavaVisitor<T> extends ParseTreeVisitor<T> {
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#primitiveType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitPrimitiveType(DroppingJavaParser.PrimitiveTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#numericType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitNumericType(DroppingJavaParser.NumericTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#integralType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitIntegralType(DroppingJavaParser.IntegralTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#floatingPointType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitFloatingPointType(DroppingJavaParser.FloatingPointTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#referenceType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitReferenceType(DroppingJavaParser.ReferenceTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#classOrInterfaceType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitClassOrInterfaceType(DroppingJavaParser.ClassOrInterfaceTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#classType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitClassType(DroppingJavaParser.ClassTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#classType_lf_classOrInterfaceType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitClassType_lf_classOrInterfaceType(DroppingJavaParser.ClassType_lf_classOrInterfaceTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#classType_lfno_classOrInterfaceType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitClassType_lfno_classOrInterfaceType(DroppingJavaParser.ClassType_lfno_classOrInterfaceTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#interfaceType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitInterfaceType(DroppingJavaParser.InterfaceTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#interfaceType_lf_classOrInterfaceType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitInterfaceType_lf_classOrInterfaceType(DroppingJavaParser.InterfaceType_lf_classOrInterfaceTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#interfaceType_lfno_classOrInterfaceType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitInterfaceType_lfno_classOrInterfaceType(DroppingJavaParser.InterfaceType_lfno_classOrInterfaceTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#typeVariable}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitTypeVariable(DroppingJavaParser.TypeVariableContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#arrayType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitArrayType(DroppingJavaParser.ArrayTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#dims}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitDims(DroppingJavaParser.DimsContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#typeParameter}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitTypeParameter(DroppingJavaParser.TypeParameterContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#typeParameterModifier}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitTypeParameterModifier(DroppingJavaParser.TypeParameterModifierContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#typeBound}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitTypeBound(DroppingJavaParser.TypeBoundContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#additionalBound}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitAdditionalBound(DroppingJavaParser.AdditionalBoundContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#typeArguments}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitTypeArguments(DroppingJavaParser.TypeArgumentsContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#typeArgumentList}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitTypeArgumentList(DroppingJavaParser.TypeArgumentListContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#typeArgument}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitTypeArgument(DroppingJavaParser.TypeArgumentContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#wildcard}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitWildcard(DroppingJavaParser.WildcardContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#wildcardBounds}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitWildcardBounds(DroppingJavaParser.WildcardBoundsContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#typeName}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitTypeName(DroppingJavaParser.TypeNameContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#packageOrTypeName}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitPackageOrTypeName(DroppingJavaParser.PackageOrTypeNameContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#compilationUnit}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitCompilationUnit(DroppingJavaParser.CompilationUnitContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#packageDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitPackageDeclaration(DroppingJavaParser.PackageDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#packageModifier}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitPackageModifier(DroppingJavaParser.PackageModifierContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#importDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitImportDeclaration(DroppingJavaParser.ImportDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#singleTypeImportDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitSingleTypeImportDeclaration(DroppingJavaParser.SingleTypeImportDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#typeImportOnDemandDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitTypeImportOnDemandDeclaration(DroppingJavaParser.TypeImportOnDemandDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#singleStaticImportDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitSingleStaticImportDeclaration(DroppingJavaParser.SingleStaticImportDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#staticImportOnDemandDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitStaticImportOnDemandDeclaration(DroppingJavaParser.StaticImportOnDemandDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#typeDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitTypeDeclaration(DroppingJavaParser.TypeDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#classDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitClassDeclaration(DroppingJavaParser.ClassDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#normalClassDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitNormalClassDeclaration(DroppingJavaParser.NormalClassDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#classModifier}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitClassModifier(DroppingJavaParser.ClassModifierContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#typeParameters}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitTypeParameters(DroppingJavaParser.TypeParametersContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#typeParameterList}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitTypeParameterList(DroppingJavaParser.TypeParameterListContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#superclass}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitSuperclass(DroppingJavaParser.SuperclassContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#superinterfaces}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitSuperinterfaces(DroppingJavaParser.SuperinterfacesContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#interfaceTypeList}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitInterfaceTypeList(DroppingJavaParser.InterfaceTypeListContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#classBody}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitClassBody(DroppingJavaParser.ClassBodyContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#classBodyDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitClassBodyDeclaration(DroppingJavaParser.ClassBodyDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#classMemberDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitClassMemberDeclaration(DroppingJavaParser.ClassMemberDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#fieldDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitFieldDeclaration(DroppingJavaParser.FieldDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#fieldModifier}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitFieldModifier(DroppingJavaParser.FieldModifierContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#variableDeclaratorList}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitVariableDeclaratorList(DroppingJavaParser.VariableDeclaratorListContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#variableDeclarator}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitVariableDeclarator(DroppingJavaParser.VariableDeclaratorContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#variableDeclaratorId}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitVariableDeclaratorId(DroppingJavaParser.VariableDeclaratorIdContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#variableInitializer}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitVariableInitializer(DroppingJavaParser.VariableInitializerContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#unannType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitUnannType(DroppingJavaParser.UnannTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#unannPrimitiveType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitUnannPrimitiveType(DroppingJavaParser.UnannPrimitiveTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#unannReferenceType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitUnannReferenceType(DroppingJavaParser.UnannReferenceTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#unannClassOrInterfaceType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitUnannClassOrInterfaceType(DroppingJavaParser.UnannClassOrInterfaceTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#unannClassType_lf_unannClassOrInterfaceType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitUnannClassType_lf_unannClassOrInterfaceType(DroppingJavaParser.UnannClassType_lf_unannClassOrInterfaceTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#unannClassType_lfno_unannClassOrInterfaceType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitUnannClassType_lfno_unannClassOrInterfaceType(DroppingJavaParser.UnannClassType_lfno_unannClassOrInterfaceTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#unannInterfaceType_lf_unannClassOrInterfaceType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitUnannInterfaceType_lf_unannClassOrInterfaceType(DroppingJavaParser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#unannInterfaceType_lfno_unannClassOrInterfaceType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitUnannInterfaceType_lfno_unannClassOrInterfaceType(DroppingJavaParser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#unannTypeVariable}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitUnannTypeVariable(DroppingJavaParser.UnannTypeVariableContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#unannArrayType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitUnannArrayType(DroppingJavaParser.UnannArrayTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#methodDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitMethodDeclaration(DroppingJavaParser.MethodDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#methodModifier}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitMethodModifier(DroppingJavaParser.MethodModifierContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#methodHeader}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitMethodHeader(DroppingJavaParser.MethodHeaderContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#result}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitResult(DroppingJavaParser.ResultContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#methodDeclarator}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitMethodDeclarator(DroppingJavaParser.MethodDeclaratorContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#formalParameterList}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitFormalParameterList(DroppingJavaParser.FormalParameterListContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#formalParameters}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitFormalParameters(DroppingJavaParser.FormalParametersContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#formalParameter}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitFormalParameter(DroppingJavaParser.FormalParameterContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#variableModifier}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitVariableModifier(DroppingJavaParser.VariableModifierContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#lastFormalParameter}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitLastFormalParameter(DroppingJavaParser.LastFormalParameterContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#receiverParameter}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitReceiverParameter(DroppingJavaParser.ReceiverParameterContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#throws_}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitThrows_(DroppingJavaParser.Throws_Context ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#exceptionTypeList}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitExceptionTypeList(DroppingJavaParser.ExceptionTypeListContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#exceptionType}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitExceptionType(DroppingJavaParser.ExceptionTypeContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#methodBody}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitMethodBody(DroppingJavaParser.MethodBodyContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#instanceInitializer}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitInstanceInitializer(DroppingJavaParser.InstanceInitializerContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#staticInitializer}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitStaticInitializer(DroppingJavaParser.StaticInitializerContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#constructorDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitConstructorDeclaration(DroppingJavaParser.ConstructorDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#constructorModifier}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitConstructorModifier(DroppingJavaParser.ConstructorModifierContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#constructorDeclarator}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitConstructorDeclarator(DroppingJavaParser.ConstructorDeclaratorContext ctx);
+	/**
+	 * Visit a parse tree produced by the {@code ConstructorName}
+	 * labeled alternative in {@link DroppingJavaParser#simpleTypeName}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitConstructorName(DroppingJavaParser.ConstructorNameContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#constructorBody}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitConstructorBody(DroppingJavaParser.ConstructorBodyContext ctx);
+	/**
+	 * Visit a parse tree produced by the {@code EnumName}
+	 * labeled alternative in {@link DroppingJavaParser#enumDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitEnumName(DroppingJavaParser.EnumNameContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#enumBody}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitEnumBody(DroppingJavaParser.EnumBodyContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#enumConstantList}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitEnumConstantList(DroppingJavaParser.EnumConstantListContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#enumConstant}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitEnumConstant(DroppingJavaParser.EnumConstantContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#enumConstantModifier}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitEnumConstantModifier(DroppingJavaParser.EnumConstantModifierContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#enumBodyDeclarations}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitEnumBodyDeclarations(DroppingJavaParser.EnumBodyDeclarationsContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#argumentList}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitArgumentList(DroppingJavaParser.ArgumentListContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#expression}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitExpression(DroppingJavaParser.ExpressionContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#conditionalExpression}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitConditionalExpression(DroppingJavaParser.ConditionalExpressionContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#interfaceDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitInterfaceDeclaration(DroppingJavaParser.InterfaceDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by the {@code IfaceName}
+	 * labeled alternative in {@link DroppingJavaParser#normalInterfaceDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitIfaceName(DroppingJavaParser.IfaceNameContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#interfaceModifier}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitInterfaceModifier(DroppingJavaParser.InterfaceModifierContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#extendsInterfaces}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitExtendsInterfaces(DroppingJavaParser.ExtendsInterfacesContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#interfaceBody}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitInterfaceBody(DroppingJavaParser.InterfaceBodyContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#interfaceMemberDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitInterfaceMemberDeclaration(DroppingJavaParser.InterfaceMemberDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#constantDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitConstantDeclaration(DroppingJavaParser.ConstantDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#constantModifier}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitConstantModifier(DroppingJavaParser.ConstantModifierContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#interfaceMethodDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitInterfaceMethodDeclaration(DroppingJavaParser.InterfaceMethodDeclarationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#interfaceMethodModifier}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitInterfaceMethodModifier(DroppingJavaParser.InterfaceMethodModifierContext ctx);
+	/**
+	 * Visit a parse tree produced by the {@code AnnoName}
+	 * labeled alternative in {@link DroppingJavaParser#annotationTypeDeclaration}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitAnnoName(DroppingJavaParser.AnnoNameContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#annotationTypeBody}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitAnnotationTypeBody(DroppingJavaParser.AnnotationTypeBodyContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#annotation}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitAnnotation(DroppingJavaParser.AnnotationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#normalAnnotation}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitNormalAnnotation(DroppingJavaParser.NormalAnnotationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#elementValuePairList}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitElementValuePairList(DroppingJavaParser.ElementValuePairListContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#elementValuePair}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitElementValuePair(DroppingJavaParser.ElementValuePairContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#elementValue}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitElementValue(DroppingJavaParser.ElementValueContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#elementValueArrayInitializer}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitElementValueArrayInitializer(DroppingJavaParser.ElementValueArrayInitializerContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#elementValueList}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitElementValueList(DroppingJavaParser.ElementValueListContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#markerAnnotation}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitMarkerAnnotation(DroppingJavaParser.MarkerAnnotationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#singleElementAnnotation}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitSingleElementAnnotation(DroppingJavaParser.SingleElementAnnotationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#arrayInitializer}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitArrayInitializer(DroppingJavaParser.ArrayInitializerContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#variableInitializerList}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitVariableInitializerList(DroppingJavaParser.VariableInitializerListContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#block}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitBlock(DroppingJavaParser.BlockContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link DroppingJavaParser#blockStatements}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitBlockStatements(DroppingJavaParser.BlockStatementsContext ctx);
+}
\ No newline at end of file
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/Argument.java b/src/main/java/ru/ftc/upc/testing/dropper/model/Argument.java
new file mode 100644
index 0000000..2f5fb55
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/model/Argument.java
@@ -0,0 +1,30 @@
+package ru.ftc.upc.testing.dropper.model;
+
+/**
+ * @author Toparvion
+ */
+public class Argument {
+  private final String type;
+  private final String name;
+
+  public Argument(String type, String name) {
+    this.type = type;
+    this.name = name;
+  }
+
+  public String getType() {
+    return type;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  @Override
+  public String toString() {
+    return "Argument{" +
+            "type='" + type + '\'' +
+            ", name='" + name + '\'' +
+            '}';
+  }
+}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
new file mode 100644
index 0000000..55afb78
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
@@ -0,0 +1,86 @@
+package ru.ftc.upc.testing.dropper.model;
+
+import ru.ftc.upc.testing.dropper.Cutpoint;
+
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * @author Toparvion
+ */
+public class TargetMethod {
+  private String name;
+  private Cutpoint cutpoint;
+  private String text;
+  private String resultType;
+  private List<Argument> formalParams = new LinkedList<Argument>();
+
+  public TargetMethod(String name) {
+    this.name = name;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public Cutpoint getCutpoint() {
+    return cutpoint;
+  }
+
+  public void setCutpoint(Cutpoint cutpoint) {
+    this.cutpoint = cutpoint;
+  }
+
+  public String getText() {
+    return text;
+  }
+
+  public void setText(String text) {
+    this.text = text;
+  }
+
+  public List<Argument> getFormalParams() {
+    return formalParams;
+  }
+
+  public String getResultType() {
+    return resultType;
+  }
+
+  public void setResultType(String resultType) {
+    this.resultType = resultType;
+  }
+
+  @Override
+  public String toString() {
+    return "TargetMethod{" +
+            "name='" + name + '\'' +
+            ", cutpoint=" + cutpoint +
+            ", text='" + text + '\'' +
+            ", resultType=" + resultType +
+            ", formalParams=" + listParamsToString(formalParams) +
+            '}';
+  }
+
+  private String listParamsToString(List<Argument> formalParams) {
+    StringBuilder sb = new StringBuilder("(");
+    boolean isFirst = true;
+    for (Argument argument: formalParams) {
+      if (!isFirst) {
+        sb.append(", ");
+      } else {
+        isFirst = false;
+      }
+      sb.append(argument.getType())
+              .append(" ")
+              .append(argument.getName());
+    }
+    sb.append(")");
+    return sb.toString();
+  }
+
+}
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java
new file mode 100644
index 0000000..b4bfe3d
--- /dev/null
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java
@@ -0,0 +1,76 @@
+package ru.ftc.upc.testing.dropper.lang;
+
+import org.antlr.v4.runtime.ANTLRFileStream;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.TokenStream;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+import org.junit.Assert;
+import org.junit.Test;
+import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaLexer;
+import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
+
+import java.io.IOException;
+
+/**
+ * @author Toparvion
+ */
+public class DropperTreeListenerTest {
+
+  @Test
+  public void nestedClassesAreRecognizedFully() throws Exception {
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/MultiNestedClasses.java";
+    TargetsMap targetsMap = loadDroplet(dropletPath);
+    String expected = "MultiNestedClasses -> {\n" +
+            "\tTargetMethod{name='method1', cutpoint=null, text='null', resultType=int, formalParams=()}\n" +
+            "\tTargetMethod{name='method4', cutpoint=null, text='null', resultType=int, formalParams=()}\n" +
+            "\tTargetMethod{name='method7', cutpoint=null, text='null', resultType=int, formalParams=()}\n" +
+            "}\n" +
+            "MultiNestedClasses.InnerClass1 -> {\n" +
+            "\tTargetMethod{name='method2', cutpoint=null, text='null', resultType=int, formalParams=()}\n" +
+            "\tTargetMethod{name='method3', cutpoint=null, text='null', resultType=int, formalParams=()}\n" +
+            "}\n" +
+            "MultiNestedClasses.InnerClass2 -> {\n" +
+            "\tTargetMethod{name='method5', cutpoint=null, text='null', resultType=int, formalParams=()}\n" +
+            "}\n" +
+            "MultiNestedClasses.InnerClass2.InnerClass3 -> {\n" +
+            "\tTargetMethod{name='method6', cutpoint=null, text='null', resultType=int, formalParams=()}\n" +
+            "}\n";
+    String actual = targetsMap.toString();
+    Assert.assertEquals(expected, actual);
+    System.out.println(actual);
+  }
+
+  @Test
+  public void methodsAreRecognizedFully() throws Exception {
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/VariousMethodHeaders.java";
+    TargetsMap targetsMap = loadDroplet(dropletPath);
+    String expected = "VariousMethodHeaders -> {\n" +
+            "\tTargetMethod{name='method1', cutpoint=null, text='null', resultType=void, formalParams=()}\n" +
+            "\tTargetMethod{name='method2', cutpoint=null, text='null', resultType=void, formalParams=(int a)}\n" +
+            "\tTargetMethod{name='method3', cutpoint=null, text='null', resultType=void, formalParams=(Map map)}\n" +
+            "\tTargetMethod{name='method4', cutpoint=null, text='null', resultType=void, formalParams=(List xs)}\n" +
+            "\tTargetMethod{name='method5', cutpoint=null, text='null', resultType=void, formalParams=(UUID u1, Date d2)}\n" +
+            "\tTargetMethod{name='method6', cutpoint=null, text='null', resultType=void, formalParams=(double d1, double d2)}\n" +
+            "\tTargetMethod{name='method7', cutpoint=null, text='null', resultType=double, formalParams=()}\n" +
+            "\tTargetMethod{name='method8', cutpoint=null, text='null', resultType=Set, formalParams=(EventObject eo)}\n" +
+            "}\n";
+    String actual = targetsMap.toString();
+    Assert.assertEquals(expected, actual);
+    System.out.println(actual);
+  }
+
+  private TargetsMap loadDroplet(String dropletPath) throws IOException {
+    ANTLRFileStream fileStream = new ANTLRFileStream(dropletPath);
+    DroppingJavaLexer lexer = new DroppingJavaLexer(fileStream);
+    TokenStream tokenStream = new CommonTokenStream(lexer);
+    DroppingJavaParser parser = new DroppingJavaParser(tokenStream);
+    ParseTree tree = parser.compilationUnit();
+
+    DropperTreeListener listener = new DropperTreeListener();
+    ParseTreeWalker walker = new ParseTreeWalker();
+    walker.walk(listener, tree);
+
+    return listener.getTargetsMap();
+  }
+}
\ No newline at end of file

From de3261d4cf666b3156def9a7ff9aca8905f622bf Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Sun, 29 May 2016 00:38:31 +0600
Subject: [PATCH 03/22] UPCSEC-0000 Implemented assembling of method bodies

---
 .../dropper/lang/BodyAssembleTreeVisitor.java | 23 ++++++
 .../dropper/lang/DropperTreeListener.java     | 54 ++++----------
 .../dropper/lang/FirstIdTreeVisitor.java      | 21 ++++++
 .../upc/testing/dropper/lang/TargetsMap.java  | 14 ++--
 .../upc/testing/dropper/model/Droplet.java    |  8 +++
 .../testing/dropper/model/TargetMethod.java   |  2 +-
 .../dropper/lang/DropperTreeListenerTest.java | 71 ++++++++++++++-----
 7 files changed, 127 insertions(+), 66 deletions(-)
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/BodyAssembleTreeVisitor.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/FirstIdTreeVisitor.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/model/Droplet.java

diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/BodyAssembleTreeVisitor.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/BodyAssembleTreeVisitor.java
new file mode 100644
index 0000000..7bf958c
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/BodyAssembleTreeVisitor.java
@@ -0,0 +1,23 @@
+package ru.ftc.upc.testing.dropper.lang;
+
+import org.antlr.v4.runtime.tree.TerminalNode;
+import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaBaseVisitor;
+
+/**
+ * A parse tree visitor for assembling all the child terminal node's texts into single string separated with spaces.
+ * @author Toparvion
+ */
+class BodyAssembleTreeVisitor extends DroppingJavaBaseVisitor<String> {
+
+  @Override
+  public String visitTerminal(TerminalNode node) {
+    return node.getText();
+  }
+
+  @Override
+  protected String aggregateResult(String aggregate, String nextResult) {
+    return (aggregate == null)
+            ? nextResult
+            : String.format("%s %s", aggregate, nextResult);
+  }
+}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java
index e629de2..670917c 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java
@@ -1,11 +1,7 @@
 package ru.ftc.upc.testing.dropper.lang;
 
-import org.antlr.v4.runtime.ParserRuleContext;
 import org.antlr.v4.runtime.RuleContext;
-import org.antlr.v4.runtime.tree.RuleNode;
-import org.antlr.v4.runtime.tree.TerminalNode;
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaBaseListener;
-import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaBaseVisitor;
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaVisitor;
 import ru.ftc.upc.testing.dropper.model.Argument;
@@ -20,17 +16,17 @@
  */
 public class DropperTreeListener extends DroppingJavaBaseListener {
 
-  private Deque<String> classStack = new LinkedList<String>();
+  private Deque<String> classNameStack = new LinkedList<String>();
   private TargetsMap targetsMap = new TargetsMap();
 
   @Override
   public void enterNormalClassDeclaration(DroppingJavaParser.NormalClassDeclarationContext ctx) {
-    classStack.push(ctx.Identifier().getText());
+    classNameStack.push(ctx.Identifier().getText());
   }
 
   @Override
   public void exitNormalClassDeclaration(DroppingJavaParser.NormalClassDeclarationContext ctx) {
-    classStack.pop();
+    classNameStack.pop();
   }
 
   @Override
@@ -39,7 +35,7 @@ public void enterMethodHeader(DroppingJavaParser.MethodHeaderContext ctx) {
     String key = composeCurrentKey();
     DroppingJavaParser.MethodDeclaratorContext declarator = ctx.methodDeclarator();
     TargetMethod method = new TargetMethod(declarator.Identifier().getText());
-    targetsMap.appendMethod(key, method);
+    targetsMap.put(key, method);
 
     // store method's result type name
     DroppingJavaParser.ResultContext result = ctx.result();
@@ -75,13 +71,22 @@ public void enterMethodHeader(DroppingJavaParser.MethodHeaderContext ctx) {
     }
   }
 
+  @Override
+  public void enterBlockStatements(DroppingJavaParser.BlockStatementsContext ctx) {
+    DroppingJavaVisitor<String> visitor = new BodyAssembleTreeVisitor();
+
+    String bodyText = visitor.visit(ctx);
+    TargetMethod currentMethod = targetsMap.get(composeCurrentKey()).getLast();
+    currentMethod.setText(bodyText);
+  }
+
   /**
-   * @return a key for target class map (basing on current state of the stack)
+   * @return a key for targets map (composed basing on current state of the stack)
    */
   private String composeCurrentKey() {
     StringBuilder sb = new StringBuilder();
     boolean first = true;
-    for (Iterator<String> iterator = classStack.descendingIterator(); iterator.hasNext(); ) {
+    for (Iterator<String> iterator = classNameStack.descendingIterator(); iterator.hasNext(); ) {
       String className = iterator.next();
       if (!first) {
         sb.append(".");
@@ -98,38 +103,9 @@ public TargetsMap getTargetsMap() {
     return targetsMap;
   }
 
-  private String getSpacedText(ParserRuleContext ctx) {
-    int childCount = ctx.getChildCount();
-    if (childCount == 0) {
-      return "";
-    }
-
-    StringBuilder sb = new StringBuilder(ctx.getChild(0).getText());
-    for (int i=1; i<childCount; i++) {
-      sb.append(" ").append(ctx.getChild(i));
-    }
-
-    return sb.toString();
-  }
-
   private String getPureTypeName(RuleContext typeCtx) {
     DroppingJavaVisitor<String> visitor = new FirstIdTreeVisitor();
     return visitor.visit(typeCtx);
   }
 
-  /**
-   * Simple visitor that reaches the very first terminal node (starting from the one specified in
-   * {@link #visitTerminal} method) and returns the node's text value.
-   */
-  private static class FirstIdTreeVisitor extends DroppingJavaBaseVisitor<String> {
-    @Override
-    public String visitTerminal(TerminalNode node) {
-      return node.getText();
-    }
-
-    @Override
-    protected boolean shouldVisitNextChild(RuleNode node, String currentResult) {
-      return (currentResult == null);
-    }
-  }
 }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/FirstIdTreeVisitor.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/FirstIdTreeVisitor.java
new file mode 100644
index 0000000..cd72f7f
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/FirstIdTreeVisitor.java
@@ -0,0 +1,21 @@
+package ru.ftc.upc.testing.dropper.lang;
+
+import org.antlr.v4.runtime.tree.RuleNode;
+import org.antlr.v4.runtime.tree.TerminalNode;
+import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaBaseVisitor;
+
+/**
+ * Simple visitor that reaches the very first terminal node (starting from the one specified in
+ * {@link #visitTerminal} method) and returns the node's text value.
+ */
+class FirstIdTreeVisitor extends DroppingJavaBaseVisitor<String> {
+  @Override
+  public String visitTerminal(TerminalNode node) {
+    return node.getText();
+  }
+
+  @Override
+  protected boolean shouldVisitNextChild(RuleNode node, String currentResult) {
+    return (currentResult == null);
+  }
+}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/TargetsMap.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/TargetsMap.java
index cfa562d..d551d3c 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/TargetsMap.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/TargetsMap.java
@@ -2,32 +2,32 @@
 
 import ru.ftc.upc.testing.dropper.model.TargetMethod;
 
+import java.util.Deque;
 import java.util.LinkedList;
-import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
 
 /**
  * @author Toparvion
  */
-public class TargetsMap extends TreeMap<String, List<TargetMethod>> {
+public class TargetsMap extends TreeMap<String, Deque<TargetMethod>> {
 
-  public void appendMethod(String key, TargetMethod method) {
-    List<TargetMethod> methods = this.get(key);
+  public void put(String key, TargetMethod method) {
+    Deque<TargetMethod> methods = this.get(key);
     if (methods == null) {
       methods = new LinkedList<TargetMethod>();
-      methods.add(method);
+      methods.addLast(method);
       this.put(key, methods);
 
     } else {
-      methods.add(method);
+      methods.addLast(method);
     }
   }
 
   @Override
   public String toString() {
     StringBuilder sb = new StringBuilder();
-    for (Map.Entry<String, List<TargetMethod>> entry : this.entrySet()) {
+    for (Map.Entry<String, Deque<TargetMethod>> entry : this.entrySet()) {
       sb.append(entry.getKey()).append(" -> {\n");
       for (TargetMethod method : entry.getValue()) {
         sb.append("\t").append(method).append("\n");
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/Droplet.java b/src/main/java/ru/ftc/upc/testing/dropper/model/Droplet.java
new file mode 100644
index 0000000..52a723e
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/model/Droplet.java
@@ -0,0 +1,8 @@
+package ru.ftc.upc.testing.dropper.model;
+
+/**
+ * @author Toparvion
+ */
+public class Droplet {
+
+}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
index 55afb78..313f072 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
@@ -60,9 +60,9 @@ public String toString() {
     return "TargetMethod{" +
             "name='" + name + '\'' +
             ", cutpoint=" + cutpoint +
-            ", text='" + text + '\'' +
             ", resultType=" + resultType +
             ", formalParams=" + listParamsToString(formalParams) +
+            ", text=" + (text == null || text.isEmpty() ? "" : "\n\t\t"+text+"\n\t") +
             '}';
   }
 
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java
index b4bfe3d..2d5a139 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java
@@ -5,13 +5,14 @@
 import org.antlr.v4.runtime.TokenStream;
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.ParseTreeWalker;
-import org.junit.Assert;
 import org.junit.Test;
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaLexer;
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
 
 import java.io.IOException;
 
+import static org.junit.Assert.assertEquals;
+
 /**
  * @author Toparvion
  */
@@ -22,41 +23,73 @@ public void nestedClassesAreRecognizedFully() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/MultiNestedClasses.java";
     TargetsMap targetsMap = loadDroplet(dropletPath);
     String expected = "MultiNestedClasses -> {\n" +
-            "\tTargetMethod{name='method1', cutpoint=null, text='null', resultType=int, formalParams=()}\n" +
-            "\tTargetMethod{name='method4', cutpoint=null, text='null', resultType=int, formalParams=()}\n" +
-            "\tTargetMethod{name='method7', cutpoint=null, text='null', resultType=int, formalParams=()}\n" +
+            "\tTargetMethod{name='method1', cutpoint=null, resultType=int, formalParams=(), text=\n" +
+            "\t\treturn 1 ;\n" +
+            "\t}\n" +
+            "\tTargetMethod{name='method4', cutpoint=null, resultType=int, formalParams=(), text=\n" +
+            "\t\treturn 4 ;\n" +
+            "\t}\n" +
+            "\tTargetMethod{name='method7', cutpoint=null, resultType=int, formalParams=(), text=\n" +
+            "\t\treturn 7 ;\n" +
+            "\t}\n" +
             "}\n" +
             "MultiNestedClasses.InnerClass1 -> {\n" +
-            "\tTargetMethod{name='method2', cutpoint=null, text='null', resultType=int, formalParams=()}\n" +
-            "\tTargetMethod{name='method3', cutpoint=null, text='null', resultType=int, formalParams=()}\n" +
+            "\tTargetMethod{name='method2', cutpoint=null, resultType=int, formalParams=(), text=\n" +
+            "\t\treturn 2 ;\n" +
+            "\t}\n" +
+            "\tTargetMethod{name='method3', cutpoint=null, resultType=int, formalParams=(), text=\n" +
+            "\t\treturn 3 ;\n" +
+            "\t}\n" +
             "}\n" +
             "MultiNestedClasses.InnerClass2 -> {\n" +
-            "\tTargetMethod{name='method5', cutpoint=null, text='null', resultType=int, formalParams=()}\n" +
+            "\tTargetMethod{name='method5', cutpoint=null, resultType=int, formalParams=(), text=\n" +
+            "\t\treturn 5 ;\n" +
+            "\t}\n" +
             "}\n" +
             "MultiNestedClasses.InnerClass2.InnerClass3 -> {\n" +
-            "\tTargetMethod{name='method6', cutpoint=null, text='null', resultType=int, formalParams=()}\n" +
+            "\tTargetMethod{name='method6', cutpoint=null, resultType=int, formalParams=(), text=\n" +
+            "\t\treturn 6 ;\n" +
+            "\t}\n" +
             "}\n";
     String actual = targetsMap.toString();
-    Assert.assertEquals(expected, actual);
+    assertEquals(expected, actual);
     System.out.println(actual);
   }
 
   @Test
-  public void methodsAreRecognizedFully() throws Exception {
+  public void methodHeadersAreRecognizedFully() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/VariousMethodHeaders.java";
     TargetsMap targetsMap = loadDroplet(dropletPath);
     String expected = "VariousMethodHeaders -> {\n" +
-            "\tTargetMethod{name='method1', cutpoint=null, text='null', resultType=void, formalParams=()}\n" +
-            "\tTargetMethod{name='method2', cutpoint=null, text='null', resultType=void, formalParams=(int a)}\n" +
-            "\tTargetMethod{name='method3', cutpoint=null, text='null', resultType=void, formalParams=(Map map)}\n" +
-            "\tTargetMethod{name='method4', cutpoint=null, text='null', resultType=void, formalParams=(List xs)}\n" +
-            "\tTargetMethod{name='method5', cutpoint=null, text='null', resultType=void, formalParams=(UUID u1, Date d2)}\n" +
-            "\tTargetMethod{name='method6', cutpoint=null, text='null', resultType=void, formalParams=(double d1, double d2)}\n" +
-            "\tTargetMethod{name='method7', cutpoint=null, text='null', resultType=double, formalParams=()}\n" +
-            "\tTargetMethod{name='method8', cutpoint=null, text='null', resultType=Set, formalParams=(EventObject eo)}\n" +
+            "\tTargetMethod{name='method1', cutpoint=null, resultType=void, formalParams=(), text=}\n" +
+            "\tTargetMethod{name='method2', cutpoint=null, resultType=void, formalParams=(int a), text=}\n" +
+            "\tTargetMethod{name='method3', cutpoint=null, resultType=void, formalParams=(Map map), text=}\n" +
+            "\tTargetMethod{name='method4', cutpoint=null, resultType=void, formalParams=(List xs), text=}\n" +
+            "\tTargetMethod{name='method5', cutpoint=null, resultType=void, formalParams=(UUID u1, Date d2), text=}\n" +
+            "\tTargetMethod{name='method6', cutpoint=null, resultType=void, formalParams=(double d1, double d2), text=}\n" +
+            "\tTargetMethod{name='method7', cutpoint=null, resultType=double, formalParams=(), text=\n" +
+            "\t\treturn Math . random ( ) ;\n" +
+            "\t}\n" +
+            "\tTargetMethod{name='method8', cutpoint=null, resultType=Set, formalParams=(EventObject eo), text=\n" +
+            "\t\treturn Collections . emptySet ( ) ;\n" +
+            "\t}\n" +
+            "}\n";
+    String actual = targetsMap.toString();
+    assertEquals(expected, actual);
+    System.out.println(actual);
+  }
+
+  @Test
+  public void methodBodiesAreRecognizedFully() throws Exception {
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/MethodBodies.java";
+    TargetsMap targetsMap = loadDroplet(dropletPath);
+    String expected = "MethodBodies -> {\n" +
+            "\tTargetMethod{name='method1', cutpoint=null, resultType=boolean, formalParams=(), text=\n" +
+            "\t\tif ( Math . random ( ) > 0.5d ) { return true ; } else { return false ; }\n" +
+            "\t}\n" +
             "}\n";
     String actual = targetsMap.toString();
-    Assert.assertEquals(expected, actual);
+    assertEquals(expected, actual);
     System.out.println(actual);
   }
 

From f60fa9881ad9740095142aec4f35151a9e45212c Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Mon, 30 May 2016 14:42:05 +0600
Subject: [PATCH 04/22] UPCSEC-0000 Implemented recognition of constructor
 declarations

---
 .../dropper/lang/DropperTreeListener.java     | 37 ++++++++++++++-----
 .../upc/testing/dropper/lang/DroppingJava.g4  |  2 +-
 .../dropper/lang/FirstIdTreeVisitor.java      |  1 +
 .../lang/gen/DroppingJavaBaseListener.java    |  4 +-
 .../lang/gen/DroppingJavaBaseVisitor.java     |  2 +-
 .../dropper/lang/gen/DroppingJavaLexer.java   |  1 -
 .../lang/gen/DroppingJavaListener.java        | 10 ++---
 .../dropper/lang/gen/DroppingJavaParser.java  | 18 +++------
 .../dropper/lang/gen/DroppingJavaVisitor.java |  5 +--
 .../testing/dropper/model/TargetMethod.java   |  2 +-
 .../dropper/lang/DropperTreeListenerTest.java | 28 +++++++++-----
 11 files changed, 64 insertions(+), 46 deletions(-)

diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java
index 670917c..c099d6b 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java
@@ -29,6 +29,21 @@ public void exitNormalClassDeclaration(DroppingJavaParser.NormalClassDeclaration
     classNameStack.pop();
   }
 
+  /**
+   * We treat constructors much like any other methods but still take in account some grammar differences.
+   */
+  @Override
+  public void enterConstructorDeclarator(DroppingJavaParser.ConstructorDeclaratorContext ctx) {
+    // as we consider constructor as methods, let's firstly save it
+    String key = composeCurrentKey();
+    TargetMethod method = new TargetMethod(ctx.simpleTypeName().getText());
+    targetsMap.put(key, method);
+
+    // There is no result type for constructors so we pass setting Method's result field. Proceed to formal parameters.
+    DroppingJavaParser.FormalParameterListContext anyParams = ctx.formalParameterList();
+    storeMethodParams(method, anyParams);
+  }
+
   @Override
   public void enterMethodHeader(DroppingJavaParser.MethodHeaderContext ctx) {
     // first of all let's save this method itself
@@ -44,6 +59,19 @@ public void enterMethodHeader(DroppingJavaParser.MethodHeaderContext ctx) {
 
     // it's time to store method parameters, if any
     DroppingJavaParser.FormalParameterListContext anyParams = declarator.formalParameterList();
+    storeMethodParams(method, anyParams);
+  }
+
+  @Override
+  public void enterBlockStatements(DroppingJavaParser.BlockStatementsContext ctx) {
+    DroppingJavaVisitor<String> visitor = new BodyAssembleTreeVisitor();
+
+    String bodyText = visitor.visit(ctx);
+    TargetMethod currentMethod = targetsMap.get(composeCurrentKey()).getLast();
+    currentMethod.setText(bodyText);
+  }
+
+  private void storeMethodParams(TargetMethod method, DroppingJavaParser.FormalParameterListContext anyParams) {
     if (anyParams == null) return;
     String paramType;
     String paramName;
@@ -71,15 +99,6 @@ public void enterMethodHeader(DroppingJavaParser.MethodHeaderContext ctx) {
     }
   }
 
-  @Override
-  public void enterBlockStatements(DroppingJavaParser.BlockStatementsContext ctx) {
-    DroppingJavaVisitor<String> visitor = new BodyAssembleTreeVisitor();
-
-    String bodyText = visitor.visit(ctx);
-    TargetMethod currentMethod = targetsMap.get(composeCurrentKey()).getLast();
-    currentMethod.setText(bodyText);
-  }
-
   /**
    * @return a key for targets map (composed basing on current state of the stack)
    */
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4 b/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4
index 74615d9..e7b77d0 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4
@@ -460,7 +460,7 @@ constructorDeclarator
 	;
 
 simpleTypeName
-	:	Identifier                              # ConstructorName
+	:	Identifier
 	;
 
 constructorBody
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/FirstIdTreeVisitor.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/FirstIdTreeVisitor.java
index cd72f7f..4bfab5f 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/FirstIdTreeVisitor.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/FirstIdTreeVisitor.java
@@ -9,6 +9,7 @@
  * {@link #visitTerminal} method) and returns the node's text value.
  */
 class FirstIdTreeVisitor extends DroppingJavaBaseVisitor<String> {
+
   @Override
   public String visitTerminal(TerminalNode node) {
     return node.getText();
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java
index bc16085..6e34c2f 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java
@@ -1000,13 +1000,13 @@ public class DroppingJavaBaseListener implements DroppingJavaListener {
 	 *
 	 * <p>The default implementation does nothing.</p>
 	 */
-	@Override public void enterConstructorName(DroppingJavaParser.ConstructorNameContext ctx) { }
+	@Override public void enterSimpleTypeName(DroppingJavaParser.SimpleTypeNameContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *
 	 * <p>The default implementation does nothing.</p>
 	 */
-	@Override public void exitConstructorName(DroppingJavaParser.ConstructorNameContext ctx) { }
+	@Override public void exitSimpleTypeName(DroppingJavaParser.SimpleTypeNameContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseVisitor.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseVisitor.java
index a58033d..8d7b605 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseVisitor.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseVisitor.java
@@ -591,7 +591,7 @@ public class DroppingJavaBaseVisitor<T> extends AbstractParseTreeVisitor<T> impl
 	 * <p>The default implementation returns the result of calling
 	 * {@link #visitChildren} on {@code ctx}.</p>
 	 */
-	@Override public T visitConstructorName(DroppingJavaParser.ConstructorNameContext ctx) { return visitChildren(ctx); }
+	@Override public T visitSimpleTypeName(DroppingJavaParser.SimpleTypeNameContext ctx) { return visitChildren(ctx); }
 	/**
 	 * {@inheritDoc}
 	 *
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.java
index bb9eab7..a3a2e20 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.java
@@ -1,6 +1,5 @@
 // Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\DroppingJava.g4 by ANTLR 4.5.1
 package ru.ftc.upc.testing.dropper.lang.gen;
-
 import org.antlr.v4.runtime.*;
 import org.antlr.v4.runtime.atn.ATN;
 import org.antlr.v4.runtime.atn.ATNDeserializer;
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java
index f2d41a3..19999a1 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java
@@ -828,17 +828,15 @@ public interface DroppingJavaListener extends ParseTreeListener {
 	 */
 	void exitConstructorDeclarator(DroppingJavaParser.ConstructorDeclaratorContext ctx);
 	/**
-	 * Enter a parse tree produced by the {@code ConstructorName}
-	 * labeled alternative in {@link DroppingJavaParser#simpleTypeName}.
+	 * Enter a parse tree produced by {@link DroppingJavaParser#simpleTypeName}.
 	 * @param ctx the parse tree
 	 */
-	void enterConstructorName(DroppingJavaParser.ConstructorNameContext ctx);
+	void enterSimpleTypeName(DroppingJavaParser.SimpleTypeNameContext ctx);
 	/**
-	 * Exit a parse tree produced by the {@code ConstructorName}
-	 * labeled alternative in {@link DroppingJavaParser#simpleTypeName}.
+	 * Exit a parse tree produced by {@link DroppingJavaParser#simpleTypeName}.
 	 * @param ctx the parse tree
 	 */
-	void exitConstructorName(DroppingJavaParser.ConstructorNameContext ctx);
+	void exitSimpleTypeName(DroppingJavaParser.SimpleTypeNameContext ctx);
 	/**
 	 * Enter a parse tree produced by {@link DroppingJavaParser#constructorBody}.
 	 * @param ctx the parse tree
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java
index 717aa2c..f9dddf4 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java
@@ -1,5 +1,6 @@
 // Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\DroppingJava.g4 by ANTLR 4.5.1
 package ru.ftc.upc.testing.dropper.lang.gen;
+
 import org.antlr.v4.runtime.*;
 import org.antlr.v4.runtime.atn.ATN;
 import org.antlr.v4.runtime.atn.ATNDeserializer;
@@ -5797,30 +5798,22 @@ public final ConstructorDeclaratorContext constructorDeclarator() throws Recogni
 	}
 
 	public static class SimpleTypeNameContext extends ParserRuleContext {
+		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
 		public SimpleTypeNameContext(ParserRuleContext parent, int invokingState) {
 			super(parent, invokingState);
 		}
 		@Override public int getRuleIndex() { return RULE_simpleTypeName; }
-	 
-		public SimpleTypeNameContext() { }
-		public void copyFrom(SimpleTypeNameContext ctx) {
-			super.copyFrom(ctx);
-		}
-	}
-	public static class ConstructorNameContext extends SimpleTypeNameContext {
-		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
-		public ConstructorNameContext(SimpleTypeNameContext ctx) { copyFrom(ctx); }
 		@Override
 		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterConstructorName(this);
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterSimpleTypeName(this);
 		}
 		@Override
 		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitConstructorName(this);
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitSimpleTypeName(this);
 		}
 		@Override
 		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
-			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitConstructorName(this);
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitSimpleTypeName(this);
 			else return visitor.visitChildren(this);
 		}
 	}
@@ -5829,7 +5822,6 @@ public final SimpleTypeNameContext simpleTypeName() throws RecognitionException
 		SimpleTypeNameContext _localctx = new SimpleTypeNameContext(_ctx, getState());
 		enterRule(_localctx, 164, RULE_simpleTypeName);
 		try {
-			_localctx = new ConstructorNameContext(_localctx);
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(868);
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaVisitor.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaVisitor.java
index 5d2e008..0010f2d 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaVisitor.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaVisitor.java
@@ -503,12 +503,11 @@ public interface DroppingJavaVisitor<T> extends ParseTreeVisitor<T> {
 	 */
 	T visitConstructorDeclarator(DroppingJavaParser.ConstructorDeclaratorContext ctx);
 	/**
-	 * Visit a parse tree produced by the {@code ConstructorName}
-	 * labeled alternative in {@link DroppingJavaParser#simpleTypeName}.
+	 * Visit a parse tree produced by {@link DroppingJavaParser#simpleTypeName}.
 	 * @param ctx the parse tree
 	 * @return the visitor result
 	 */
-	T visitConstructorName(DroppingJavaParser.ConstructorNameContext ctx);
+	T visitSimpleTypeName(DroppingJavaParser.SimpleTypeNameContext ctx);
 	/**
 	 * Visit a parse tree produced by {@link DroppingJavaParser#constructorBody}.
 	 * @param ctx the parse tree
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
index 313f072..1c74560 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
@@ -62,7 +62,7 @@ public String toString() {
             ", cutpoint=" + cutpoint +
             ", resultType=" + resultType +
             ", formalParams=" + listParamsToString(formalParams) +
-            ", text=" + (text == null || text.isEmpty() ? "" : "\n\t\t"+text+"\n\t") +
+            ", text=" + (text == null || text.isEmpty() ? "(empty)" : "\n\t\t"+text+"\n\t") +
             '}';
   }
 
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java
index 2d5a139..9a01fb5 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java
@@ -52,8 +52,8 @@ public void nestedClassesAreRecognizedFully() throws Exception {
             "\t}\n" +
             "}\n";
     String actual = targetsMap.toString();
-    assertEquals(expected, actual);
     System.out.println(actual);
+    assertEquals(expected, actual);
   }
 
   @Test
@@ -61,22 +61,28 @@ public void methodHeadersAreRecognizedFully() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/VariousMethodHeaders.java";
     TargetsMap targetsMap = loadDroplet(dropletPath);
     String expected = "VariousMethodHeaders -> {\n" +
-            "\tTargetMethod{name='method1', cutpoint=null, resultType=void, formalParams=(), text=}\n" +
-            "\tTargetMethod{name='method2', cutpoint=null, resultType=void, formalParams=(int a), text=}\n" +
-            "\tTargetMethod{name='method3', cutpoint=null, resultType=void, formalParams=(Map map), text=}\n" +
-            "\tTargetMethod{name='method4', cutpoint=null, resultType=void, formalParams=(List xs), text=}\n" +
-            "\tTargetMethod{name='method5', cutpoint=null, resultType=void, formalParams=(UUID u1, Date d2), text=}\n" +
-            "\tTargetMethod{name='method6', cutpoint=null, resultType=void, formalParams=(double d1, double d2), text=}\n" +
+            "\tTargetMethod{name='VariousMethodHeaders', cutpoint=null, resultType=null, formalParams=(), text=(empty)}\n" +
+            "\tTargetMethod{name='VariousMethodHeaders', cutpoint=null, resultType=null, formalParams=(Stack param1), text=(empty)}\n" +
+            "\tTargetMethod{name='VariousMethodHeaders', cutpoint=null, resultType=null, formalParams=(float arg), text=(empty)}\n" +
+            "\tTargetMethod{name='method1', cutpoint=null, resultType=void, formalParams=(), text=(empty)}\n" +
+            "\tTargetMethod{name='method2', cutpoint=null, resultType=void, formalParams=(int a), text=(empty)}\n" +
+            "\tTargetMethod{name='method3', cutpoint=null, resultType=void, formalParams=(Map map), text=(empty)}\n" +
+            "\tTargetMethod{name='method4', cutpoint=null, resultType=void, formalParams=(List xs), text=(empty)}\n" +
+            "\tTargetMethod{name='method5', cutpoint=null, resultType=void, formalParams=(UUID u1, Date d2), text=(empty)}\n" +
+            "\tTargetMethod{name='method6', cutpoint=null, resultType=void, formalParams=(double d1, double d2), text=(empty)}\n" +
             "\tTargetMethod{name='method7', cutpoint=null, resultType=double, formalParams=(), text=\n" +
             "\t\treturn Math . random ( ) ;\n" +
             "\t}\n" +
             "\tTargetMethod{name='method8', cutpoint=null, resultType=Set, formalParams=(EventObject eo), text=\n" +
             "\t\treturn Collections . emptySet ( ) ;\n" +
             "\t}\n" +
+            "}\n" +
+            "VariousMethodHeaders.InnerClass -> {\n" +
+            "\tTargetMethod{name='InnerClass', cutpoint=null, resultType=null, formalParams=(Deque arg), text=(empty)}\n" +
             "}\n";
     String actual = targetsMap.toString();
-    assertEquals(expected, actual);
     System.out.println(actual);
+    assertEquals(expected, actual);
   }
 
   @Test
@@ -84,13 +90,17 @@ public void methodBodiesAreRecognizedFully() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/MethodBodies.java";
     TargetsMap targetsMap = loadDroplet(dropletPath);
     String expected = "MethodBodies -> {\n" +
+            "\tTargetMethod{name='MethodBodies', cutpoint=null, resultType=null, formalParams=(String name), text=\n" +
+            "\t\tSystem . out . println ( \"Hello from constructor :) \" ) ;\n" +
+            "\t}\n" +
+            "\tTargetMethod{name='MethodBodies', cutpoint=null, resultType=null, formalParams=(), text=(empty)}\n" +
             "\tTargetMethod{name='method1', cutpoint=null, resultType=boolean, formalParams=(), text=\n" +
             "\t\tif ( Math . random ( ) > 0.5d ) { return true ; } else { return false ; }\n" +
             "\t}\n" +
             "}\n";
     String actual = targetsMap.toString();
-    assertEquals(expected, actual);
     System.out.println(actual);
+    assertEquals(expected, actual);
   }
 
   private TargetsMap loadDroplet(String dropletPath) throws IOException {

From cdf54242caa8724bfa207d2f12f00f10fede0841 Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Tue, 31 May 2016 14:00:36 +0600
Subject: [PATCH 05/22] UPCSEC-0000 Implemented recognition of enumerations,
 interfaces and their arbitrary combinations with classes

---
 .gitignore                                    |   2 +
 .../dropper/lang/DropperTreeListener.java     |  21 +-
 .../upc/testing/dropper/lang/DroppingJava.g4  |  14 +-
 .../dropper/lang/FirstIdTreeVisitor.java      |  22 -
 .../lang/PureTypeNameComposingVisitor.java    |  42 +
 .../lang/gen/DroppingJavaBaseListener.java    |  12 +-
 .../lang/gen/DroppingJavaBaseVisitor.java     |   6 +-
 .../lang/gen/DroppingJavaListener.java        |  30 +-
 .../dropper/lang/gen/DroppingJavaParser.java  | 786 ++++++++----------
 .../dropper/lang/gen/DroppingJavaVisitor.java |  15 +-
 .../dropper/lang/DropperTreeListenerTest.java |  99 +++
 .../resources/FaultyTypesCombination.java     |  83 ++
 src/test/resources/RootInterface.java         |  44 +
 13 files changed, 691 insertions(+), 485 deletions(-)
 delete mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/FirstIdTreeVisitor.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/PureTypeNameComposingVisitor.java
 create mode 100644 src/test/resources/FaultyTypesCombination.java
 create mode 100644 src/test/resources/RootInterface.java

diff --git a/.gitignore b/.gitignore
index babe21f..767fece 100644
--- a/.gitignore
+++ b/.gitignore
@@ -87,3 +87,5 @@ hs_err_pid*
 
 # droplets themselves are not the part of Dropper
 droplets/
+
+memo.txt
\ No newline at end of file
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java
index c099d6b..606da61 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java
@@ -23,12 +23,29 @@ public class DropperTreeListener extends DroppingJavaBaseListener {
   public void enterNormalClassDeclaration(DroppingJavaParser.NormalClassDeclarationContext ctx) {
     classNameStack.push(ctx.Identifier().getText());
   }
-
   @Override
   public void exitNormalClassDeclaration(DroppingJavaParser.NormalClassDeclarationContext ctx) {
     classNameStack.pop();
   }
 
+  @Override
+  public void enterEnumDeclaration(DroppingJavaParser.EnumDeclarationContext ctx) {
+    classNameStack.push(ctx.Identifier().getText());
+  }
+  @Override
+  public void exitEnumDeclaration(DroppingJavaParser.EnumDeclarationContext ctx) {
+    classNameStack.pop();
+  }
+
+  @Override
+  public void enterNormalInterfaceDeclaration(DroppingJavaParser.NormalInterfaceDeclarationContext ctx) {
+    classNameStack.push(ctx.Identifier().getText());
+  }
+  @Override
+  public void exitNormalInterfaceDeclaration(DroppingJavaParser.NormalInterfaceDeclarationContext ctx) {
+    classNameStack.pop();
+  }
+
   /**
    * We treat constructors much like any other methods but still take in account some grammar differences.
    */
@@ -123,7 +140,7 @@ public TargetsMap getTargetsMap() {
   }
 
   private String getPureTypeName(RuleContext typeCtx) {
-    DroppingJavaVisitor<String> visitor = new FirstIdTreeVisitor();
+    DroppingJavaVisitor<String> visitor = new PureTypeNameComposingVisitor();
     return visitor.visit(typeCtx);
   }
 
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4 b/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4
index e7b77d0..b64e149 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4
@@ -223,7 +223,7 @@ classDeclaration
 	;
 
 normalClassDeclaration
-	:	classModifier* 'class' Identifier typeParameters? superclass? superinterfaces? classBody  // # ClassName
+	:	classModifier* 'class' Identifier typeParameters? superclass? superinterfaces? classBody
 	;
 
 classModifier
@@ -468,7 +468,7 @@ constructorBody
 	;
 
 enumDeclaration
-	:	classModifier* 'enum' Identifier superinterfaces? enumBody              # EnumName
+	:	classModifier* 'enum' Identifier superinterfaces? enumBody
 	;
 
 enumBody
@@ -496,7 +496,7 @@ argumentList
 	;
 
 /*
- * Lite grammar stubs
+ * Dropping grammar stubs
  */
 
 expression
@@ -517,7 +517,7 @@ interfaceDeclaration
 	;
 
 normalInterfaceDeclaration
-	:	interfaceModifier* 'interface' Identifier typeParameters? extendsInterfaces? interfaceBody  # IfaceName
+	:	interfaceModifier* 'interface' Identifier typeParameters? extendsInterfaces? interfaceBody
 	;
 
 interfaceModifier
@@ -547,7 +547,7 @@ interfaceMemberDeclaration
 	;
 
 constantDeclaration
-	:	constantModifier* unannType .+? ';' // constantModifier* unannType variableDeclaratorList ';'
+	:	constantModifier* unannType variableDeclaratorList ';'
 	;
 
 constantModifier
@@ -571,11 +571,11 @@ interfaceMethodModifier
 	;
 
 annotationTypeDeclaration
-	:	interfaceModifier* '@' 'interface' Identifier annotationTypeBody            # AnnoName
+	:	interfaceModifier* '@' 'interface' Identifier annotationTypeBody
 	;
 
 annotationTypeBody
-	:	'{' .+? '}'            // '{' annotationTypeMemberDeclaration* '}'
+	:	'{' .*? '}'            // '{' annotationTypeMemberDeclaration* '}'
 	;
 
 annotation
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/FirstIdTreeVisitor.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/FirstIdTreeVisitor.java
deleted file mode 100644
index 4bfab5f..0000000
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/FirstIdTreeVisitor.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package ru.ftc.upc.testing.dropper.lang;
-
-import org.antlr.v4.runtime.tree.RuleNode;
-import org.antlr.v4.runtime.tree.TerminalNode;
-import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaBaseVisitor;
-
-/**
- * Simple visitor that reaches the very first terminal node (starting from the one specified in
- * {@link #visitTerminal} method) and returns the node's text value.
- */
-class FirstIdTreeVisitor extends DroppingJavaBaseVisitor<String> {
-
-  @Override
-  public String visitTerminal(TerminalNode node) {
-    return node.getText();
-  }
-
-  @Override
-  protected boolean shouldVisitNextChild(RuleNode node, String currentResult) {
-    return (currentResult == null);
-  }
-}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/PureTypeNameComposingVisitor.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/PureTypeNameComposingVisitor.java
new file mode 100644
index 0000000..8393c3d
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/PureTypeNameComposingVisitor.java
@@ -0,0 +1,42 @@
+package ru.ftc.upc.testing.dropper.lang;
+
+import org.antlr.v4.runtime.tree.TerminalNode;
+import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaBaseVisitor;
+import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
+
+/**
+ * Simple visitor that assembles a string from all the terminal nodes except {@code dims, typeArguments, annotation}.
+ */
+class PureTypeNameComposingVisitor extends DroppingJavaBaseVisitor<String> {
+
+  @Override
+  public String visitTerminal(TerminalNode node) {
+    return node.getText();
+  }
+
+  @Override
+  protected String aggregateResult(String aggregate, String nextResult) {
+    return aggregate + nextResult;
+  }
+
+  @Override
+  public String visitDims(DroppingJavaParser.DimsContext ctx) {
+    return "";
+  }
+
+  @Override
+  public String visitTypeArguments(DroppingJavaParser.TypeArgumentsContext ctx) {
+    return "";
+  }
+
+  @Override
+  public String visitAnnotation(DroppingJavaParser.AnnotationContext ctx) {
+    return "";
+  }
+
+  @Override
+  protected String defaultResult() {
+    return "";
+  }
+
+}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java
index 6e34c2f..38f7ab3 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java
@@ -1024,13 +1024,13 @@ public class DroppingJavaBaseListener implements DroppingJavaListener {
 	 *
 	 * <p>The default implementation does nothing.</p>
 	 */
-	@Override public void enterEnumName(DroppingJavaParser.EnumNameContext ctx) { }
+	@Override public void enterEnumDeclaration(DroppingJavaParser.EnumDeclarationContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *
 	 * <p>The default implementation does nothing.</p>
 	 */
-	@Override public void exitEnumName(DroppingJavaParser.EnumNameContext ctx) { }
+	@Override public void exitEnumDeclaration(DroppingJavaParser.EnumDeclarationContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *
@@ -1144,13 +1144,13 @@ public class DroppingJavaBaseListener implements DroppingJavaListener {
 	 *
 	 * <p>The default implementation does nothing.</p>
 	 */
-	@Override public void enterIfaceName(DroppingJavaParser.IfaceNameContext ctx) { }
+	@Override public void enterNormalInterfaceDeclaration(DroppingJavaParser.NormalInterfaceDeclarationContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *
 	 * <p>The default implementation does nothing.</p>
 	 */
-	@Override public void exitIfaceName(DroppingJavaParser.IfaceNameContext ctx) { }
+	@Override public void exitNormalInterfaceDeclaration(DroppingJavaParser.NormalInterfaceDeclarationContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *
@@ -1252,13 +1252,13 @@ public class DroppingJavaBaseListener implements DroppingJavaListener {
 	 *
 	 * <p>The default implementation does nothing.</p>
 	 */
-	@Override public void enterAnnoName(DroppingJavaParser.AnnoNameContext ctx) { }
+	@Override public void enterAnnotationTypeDeclaration(DroppingJavaParser.AnnotationTypeDeclarationContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *
 	 * <p>The default implementation does nothing.</p>
 	 */
-	@Override public void exitAnnoName(DroppingJavaParser.AnnoNameContext ctx) { }
+	@Override public void exitAnnotationTypeDeclaration(DroppingJavaParser.AnnotationTypeDeclarationContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseVisitor.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseVisitor.java
index 8d7b605..3332bdc 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseVisitor.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseVisitor.java
@@ -605,7 +605,7 @@ public class DroppingJavaBaseVisitor<T> extends AbstractParseTreeVisitor<T> impl
 	 * <p>The default implementation returns the result of calling
 	 * {@link #visitChildren} on {@code ctx}.</p>
 	 */
-	@Override public T visitEnumName(DroppingJavaParser.EnumNameContext ctx) { return visitChildren(ctx); }
+	@Override public T visitEnumDeclaration(DroppingJavaParser.EnumDeclarationContext ctx) { return visitChildren(ctx); }
 	/**
 	 * {@inheritDoc}
 	 *
@@ -675,7 +675,7 @@ public class DroppingJavaBaseVisitor<T> extends AbstractParseTreeVisitor<T> impl
 	 * <p>The default implementation returns the result of calling
 	 * {@link #visitChildren} on {@code ctx}.</p>
 	 */
-	@Override public T visitIfaceName(DroppingJavaParser.IfaceNameContext ctx) { return visitChildren(ctx); }
+	@Override public T visitNormalInterfaceDeclaration(DroppingJavaParser.NormalInterfaceDeclarationContext ctx) { return visitChildren(ctx); }
 	/**
 	 * {@inheritDoc}
 	 *
@@ -738,7 +738,7 @@ public class DroppingJavaBaseVisitor<T> extends AbstractParseTreeVisitor<T> impl
 	 * <p>The default implementation returns the result of calling
 	 * {@link #visitChildren} on {@code ctx}.</p>
 	 */
-	@Override public T visitAnnoName(DroppingJavaParser.AnnoNameContext ctx) { return visitChildren(ctx); }
+	@Override public T visitAnnotationTypeDeclaration(DroppingJavaParser.AnnotationTypeDeclarationContext ctx) { return visitChildren(ctx); }
 	/**
 	 * {@inheritDoc}
 	 *
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java
index 19999a1..f6f32c9 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java
@@ -848,17 +848,15 @@ public interface DroppingJavaListener extends ParseTreeListener {
 	 */
 	void exitConstructorBody(DroppingJavaParser.ConstructorBodyContext ctx);
 	/**
-	 * Enter a parse tree produced by the {@code EnumName}
-	 * labeled alternative in {@link DroppingJavaParser#enumDeclaration}.
+	 * Enter a parse tree produced by {@link DroppingJavaParser#enumDeclaration}.
 	 * @param ctx the parse tree
 	 */
-	void enterEnumName(DroppingJavaParser.EnumNameContext ctx);
+	void enterEnumDeclaration(DroppingJavaParser.EnumDeclarationContext ctx);
 	/**
-	 * Exit a parse tree produced by the {@code EnumName}
-	 * labeled alternative in {@link DroppingJavaParser#enumDeclaration}.
+	 * Exit a parse tree produced by {@link DroppingJavaParser#enumDeclaration}.
 	 * @param ctx the parse tree
 	 */
-	void exitEnumName(DroppingJavaParser.EnumNameContext ctx);
+	void exitEnumDeclaration(DroppingJavaParser.EnumDeclarationContext ctx);
 	/**
 	 * Enter a parse tree produced by {@link DroppingJavaParser#enumBody}.
 	 * @param ctx the parse tree
@@ -950,17 +948,15 @@ public interface DroppingJavaListener extends ParseTreeListener {
 	 */
 	void exitInterfaceDeclaration(DroppingJavaParser.InterfaceDeclarationContext ctx);
 	/**
-	 * Enter a parse tree produced by the {@code IfaceName}
-	 * labeled alternative in {@link DroppingJavaParser#normalInterfaceDeclaration}.
+	 * Enter a parse tree produced by {@link DroppingJavaParser#normalInterfaceDeclaration}.
 	 * @param ctx the parse tree
 	 */
-	void enterIfaceName(DroppingJavaParser.IfaceNameContext ctx);
+	void enterNormalInterfaceDeclaration(DroppingJavaParser.NormalInterfaceDeclarationContext ctx);
 	/**
-	 * Exit a parse tree produced by the {@code IfaceName}
-	 * labeled alternative in {@link DroppingJavaParser#normalInterfaceDeclaration}.
+	 * Exit a parse tree produced by {@link DroppingJavaParser#normalInterfaceDeclaration}.
 	 * @param ctx the parse tree
 	 */
-	void exitIfaceName(DroppingJavaParser.IfaceNameContext ctx);
+	void exitNormalInterfaceDeclaration(DroppingJavaParser.NormalInterfaceDeclarationContext ctx);
 	/**
 	 * Enter a parse tree produced by {@link DroppingJavaParser#interfaceModifier}.
 	 * @param ctx the parse tree
@@ -1042,17 +1038,15 @@ public interface DroppingJavaListener extends ParseTreeListener {
 	 */
 	void exitInterfaceMethodModifier(DroppingJavaParser.InterfaceMethodModifierContext ctx);
 	/**
-	 * Enter a parse tree produced by the {@code AnnoName}
-	 * labeled alternative in {@link DroppingJavaParser#annotationTypeDeclaration}.
+	 * Enter a parse tree produced by {@link DroppingJavaParser#annotationTypeDeclaration}.
 	 * @param ctx the parse tree
 	 */
-	void enterAnnoName(DroppingJavaParser.AnnoNameContext ctx);
+	void enterAnnotationTypeDeclaration(DroppingJavaParser.AnnotationTypeDeclarationContext ctx);
 	/**
-	 * Exit a parse tree produced by the {@code AnnoName}
-	 * labeled alternative in {@link DroppingJavaParser#annotationTypeDeclaration}.
+	 * Exit a parse tree produced by {@link DroppingJavaParser#annotationTypeDeclaration}.
 	 * @param ctx the parse tree
 	 */
-	void exitAnnoName(DroppingJavaParser.AnnoNameContext ctx);
+	void exitAnnotationTypeDeclaration(DroppingJavaParser.AnnotationTypeDeclarationContext ctx);
 	/**
 	 * Enter a parse tree produced by {@link DroppingJavaParser#annotationTypeBody}.
 	 * @param ctx the parse tree
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java
index f9dddf4..ed37fa0 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java
@@ -3937,8 +3937,8 @@ public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 	public final UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() throws RecognitionException {
 		UnannClassOrInterfaceTypeContext _localctx = new UnannClassOrInterfaceTypeContext(_ctx, getState());
 		enterRule(_localctx, 110, RULE_unannClassOrInterfaceType);
+		int _la;
 		try {
-			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(652);
@@ -3958,30 +3958,28 @@ public final UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() throws
 			}
 			setState(658);
 			_errHandler.sync(this);
-			_alt = getInterpreter().adaptivePredict(_input,62,_ctx);
-			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
-				if ( _alt==1 ) {
+			_la = _input.LA(1);
+			while (_la==DOT) {
+				{
+				setState(656);
+				switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
+				case 1:
 					{
-					setState(656);
-					switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
-					case 1:
-						{
-						setState(654);
-						unannClassType_lf_unannClassOrInterfaceType();
-						}
-						break;
-					case 2:
-						{
-						setState(655);
-						unannInterfaceType_lf_unannClassOrInterfaceType();
-						}
-						break;
+					setState(654);
+					unannClassType_lf_unannClassOrInterfaceType();
 					}
-					} 
+					break;
+				case 2:
+					{
+					setState(655);
+					unannInterfaceType_lf_unannClassOrInterfaceType();
+					}
+					break;
+				}
 				}
 				setState(660);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,62,_ctx);
+				_la = _input.LA(1);
 			}
 			}
 		}
@@ -4052,14 +4050,14 @@ public final UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_l
 			setState(668);
 			match(Identifier);
 			setState(670);
-			switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
-			case 1:
+			_la = _input.LA(1);
+			if (_la==LT) {
 				{
 				setState(669);
 				typeArguments();
 				}
-				break;
 			}
+
 			}
 		}
 		catch (RecognitionException re) {
@@ -4100,20 +4098,21 @@ public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
 	public final UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() throws RecognitionException {
 		UnannClassType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState());
 		enterRule(_localctx, 114, RULE_unannClassType_lfno_unannClassOrInterfaceType);
+		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(672);
 			match(Identifier);
 			setState(674);
-			switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
-			case 1:
+			_la = _input.LA(1);
+			if (_la==LT) {
 				{
 				setState(673);
 				typeArguments();
 				}
-				break;
 			}
+
 			}
 		}
 		catch (RecognitionException re) {
@@ -5888,17 +5887,6 @@ public final ConstructorBodyContext constructorBody() throws RecognitionExceptio
 	}
 
 	public static class EnumDeclarationContext extends ParserRuleContext {
-		public EnumDeclarationContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_enumDeclaration; }
-	 
-		public EnumDeclarationContext() { }
-		public void copyFrom(EnumDeclarationContext ctx) {
-			super.copyFrom(ctx);
-		}
-	}
-	public static class EnumNameContext extends EnumDeclarationContext {
 		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
 		public EnumBodyContext enumBody() {
 			return getRuleContext(EnumBodyContext.class,0);
@@ -5912,18 +5900,21 @@ public ClassModifierContext classModifier(int i) {
 		public SuperinterfacesContext superinterfaces() {
 			return getRuleContext(SuperinterfacesContext.class,0);
 		}
-		public EnumNameContext(EnumDeclarationContext ctx) { copyFrom(ctx); }
+		public EnumDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_enumDeclaration; }
 		@Override
 		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterEnumName(this);
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterEnumDeclaration(this);
 		}
 		@Override
 		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitEnumName(this);
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitEnumDeclaration(this);
 		}
 		@Override
 		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
-			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitEnumName(this);
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitEnumDeclaration(this);
 			else return visitor.visitChildren(this);
 		}
 	}
@@ -5933,7 +5924,6 @@ public final EnumDeclarationContext enumDeclaration() throws RecognitionExceptio
 		enterRule(_localctx, 168, RULE_enumDeclaration);
 		int _la;
 		try {
-			_localctx = new EnumNameContext(_localctx);
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(877);
@@ -6569,17 +6559,6 @@ public final InterfaceDeclarationContext interfaceDeclaration() throws Recogniti
 	}
 
 	public static class NormalInterfaceDeclarationContext extends ParserRuleContext {
-		public NormalInterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_normalInterfaceDeclaration; }
-	 
-		public NormalInterfaceDeclarationContext() { }
-		public void copyFrom(NormalInterfaceDeclarationContext ctx) {
-			super.copyFrom(ctx);
-		}
-	}
-	public static class IfaceNameContext extends NormalInterfaceDeclarationContext {
 		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
 		public InterfaceBodyContext interfaceBody() {
 			return getRuleContext(InterfaceBodyContext.class,0);
@@ -6596,18 +6575,21 @@ public TypeParametersContext typeParameters() {
 		public ExtendsInterfacesContext extendsInterfaces() {
 			return getRuleContext(ExtendsInterfacesContext.class,0);
 		}
-		public IfaceNameContext(NormalInterfaceDeclarationContext ctx) { copyFrom(ctx); }
+		public NormalInterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_normalInterfaceDeclaration; }
 		@Override
 		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterIfaceName(this);
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterNormalInterfaceDeclaration(this);
 		}
 		@Override
 		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitIfaceName(this);
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitNormalInterfaceDeclaration(this);
 		}
 		@Override
 		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
-			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitIfaceName(this);
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitNormalInterfaceDeclaration(this);
 			else return visitor.visitChildren(this);
 		}
 	}
@@ -6617,7 +6599,6 @@ public final NormalInterfaceDeclarationContext normalInterfaceDeclaration() thro
 		enterRule(_localctx, 188, RULE_normalInterfaceDeclaration);
 		int _la;
 		try {
-			_localctx = new IfaceNameContext(_localctx);
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(958);
@@ -6964,6 +6945,9 @@ public static class ConstantDeclarationContext extends ParserRuleContext {
 		public UnannTypeContext unannType() {
 			return getRuleContext(UnannTypeContext.class,0);
 		}
+		public VariableDeclaratorListContext variableDeclaratorList() {
+			return getRuleContext(VariableDeclaratorListContext.class,0);
+		}
 		public List<ConstantModifierContext> constantModifier() {
 			return getRuleContexts(ConstantModifierContext.class);
 		}
@@ -6994,7 +6978,6 @@ public final ConstantDeclarationContext constantDeclaration() throws Recognition
 		enterRule(_localctx, 198, RULE_constantDeclaration);
 		int _la;
 		try {
-			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(1002);
@@ -7013,27 +6996,9 @@ public final ConstantDeclarationContext constantDeclaration() throws Recognition
 			}
 			setState(1005);
 			unannType();
-			setState(1007); 
-			_errHandler.sync(this);
-			_alt = 1+1;
-			do {
-				switch (_alt) {
-				case 1+1:
-					{
-					{
-					setState(1006);
-					matchWildcard();
-					}
-					}
-					break;
-				default:
-					throw new NoViableAltException(this);
-				}
-				setState(1009); 
-				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,117,_ctx);
-			} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
-			setState(1011);
+			setState(1006);
+			variableDeclaratorList();
+			setState(1007);
 			match(SEMI);
 			}
 		}
@@ -7075,33 +7040,33 @@ public final ConstantModifierContext constantModifier() throws RecognitionExcept
 		ConstantModifierContext _localctx = new ConstantModifierContext(_ctx, getState());
 		enterRule(_localctx, 200, RULE_constantModifier);
 		try {
-			setState(1017);
+			setState(1013);
 			switch (_input.LA(1)) {
 			case AT:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(1013);
+				setState(1009);
 				annotation();
 				}
 				break;
 			case PUBLIC:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(1014);
+				setState(1010);
 				match(PUBLIC);
 				}
 				break;
 			case STATIC:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(1015);
+				setState(1011);
 				match(STATIC);
 				}
 				break;
 			case FINAL:
 				enterOuterAlt(_localctx, 4);
 				{
-				setState(1016);
+				setState(1012);
 				match(FINAL);
 				}
 				break;
@@ -7159,23 +7124,23 @@ public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() thro
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1022);
+			setState(1018);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << DEFAULT) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
 				{
 				{
-				setState(1019);
+				setState(1015);
 				interfaceMethodModifier();
 				}
 				}
-				setState(1024);
+				setState(1020);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(1025);
+			setState(1021);
 			methodHeader();
-			setState(1026);
+			setState(1022);
 			methodBody();
 			}
 		}
@@ -7217,47 +7182,47 @@ public final InterfaceMethodModifierContext interfaceMethodModifier() throws Rec
 		InterfaceMethodModifierContext _localctx = new InterfaceMethodModifierContext(_ctx, getState());
 		enterRule(_localctx, 204, RULE_interfaceMethodModifier);
 		try {
-			setState(1034);
+			setState(1030);
 			switch (_input.LA(1)) {
 			case AT:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(1028);
+				setState(1024);
 				annotation();
 				}
 				break;
 			case PUBLIC:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(1029);
+				setState(1025);
 				match(PUBLIC);
 				}
 				break;
 			case ABSTRACT:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(1030);
+				setState(1026);
 				match(ABSTRACT);
 				}
 				break;
 			case DEFAULT:
 				enterOuterAlt(_localctx, 4);
 				{
-				setState(1031);
+				setState(1027);
 				match(DEFAULT);
 				}
 				break;
 			case STATIC:
 				enterOuterAlt(_localctx, 5);
 				{
-				setState(1032);
+				setState(1028);
 				match(STATIC);
 				}
 				break;
 			case STRICTFP:
 				enterOuterAlt(_localctx, 6);
 				{
-				setState(1033);
+				setState(1029);
 				match(STRICTFP);
 				}
 				break;
@@ -7277,17 +7242,6 @@ public final InterfaceMethodModifierContext interfaceMethodModifier() throws Rec
 	}
 
 	public static class AnnotationTypeDeclarationContext extends ParserRuleContext {
-		public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_annotationTypeDeclaration; }
-	 
-		public AnnotationTypeDeclarationContext() { }
-		public void copyFrom(AnnotationTypeDeclarationContext ctx) {
-			super.copyFrom(ctx);
-		}
-	}
-	public static class AnnoNameContext extends AnnotationTypeDeclarationContext {
 		public TerminalNode Identifier() { return getToken(DroppingJavaParser.Identifier, 0); }
 		public AnnotationTypeBodyContext annotationTypeBody() {
 			return getRuleContext(AnnotationTypeBodyContext.class,0);
@@ -7298,18 +7252,21 @@ public List<InterfaceModifierContext> interfaceModifier() {
 		public InterfaceModifierContext interfaceModifier(int i) {
 			return getRuleContext(InterfaceModifierContext.class,i);
 		}
-		public AnnoNameContext(AnnotationTypeDeclarationContext ctx) { copyFrom(ctx); }
+		public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_annotationTypeDeclaration; }
 		@Override
 		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterAnnoName(this);
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).enterAnnotationTypeDeclaration(this);
 		}
 		@Override
 		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitAnnoName(this);
+			if ( listener instanceof DroppingJavaListener ) ((DroppingJavaListener)listener).exitAnnotationTypeDeclaration(this);
 		}
 		@Override
 		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
-			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitAnnoName(this);
+			if ( visitor instanceof DroppingJavaVisitor ) return ((DroppingJavaVisitor<? extends T>)visitor).visitAnnotationTypeDeclaration(this);
 			else return visitor.visitChildren(this);
 		}
 	}
@@ -7319,32 +7276,31 @@ public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws
 		enterRule(_localctx, 206, RULE_annotationTypeDeclaration);
 		try {
 			int _alt;
-			_localctx = new AnnoNameContext(_localctx);
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1039);
+			setState(1035);
 			_errHandler.sync(this);
-			_alt = getInterpreter().adaptivePredict(_input,121,_ctx);
+			_alt = getInterpreter().adaptivePredict(_input,120,_ctx);
 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 				if ( _alt==1 ) {
 					{
 					{
-					setState(1036);
+					setState(1032);
 					interfaceModifier();
 					}
 					} 
 				}
-				setState(1041);
+				setState(1037);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,121,_ctx);
+				_alt = getInterpreter().adaptivePredict(_input,120,_ctx);
 			}
-			setState(1042);
+			setState(1038);
 			match(AT);
-			setState(1043);
+			setState(1039);
 			match(INTERFACE);
-			setState(1044);
+			setState(1040);
 			match(Identifier);
-			setState(1045);
+			setState(1041);
 			annotationTypeBody();
 			}
 		}
@@ -7386,29 +7342,25 @@ public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionEx
 			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1047);
+			setState(1043);
 			match(LBRACE);
-			setState(1049); 
+			setState(1047);
 			_errHandler.sync(this);
-			_alt = 1+1;
-			do {
-				switch (_alt) {
-				case 1+1:
+			_alt = getInterpreter().adaptivePredict(_input,121,_ctx);
+			while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1+1 ) {
 					{
 					{
-					setState(1048);
+					setState(1044);
 					matchWildcard();
 					}
-					}
-					break;
-				default:
-					throw new NoViableAltException(this);
+					} 
 				}
-				setState(1051); 
+				setState(1049);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,122,_ctx);
-			} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
-			setState(1053);
+				_alt = getInterpreter().adaptivePredict(_input,121,_ctx);
+			}
+			setState(1050);
 			match(RBRACE);
 			}
 		}
@@ -7456,26 +7408,26 @@ public final AnnotationContext annotation() throws RecognitionException {
 		AnnotationContext _localctx = new AnnotationContext(_ctx, getState());
 		enterRule(_localctx, 210, RULE_annotation);
 		try {
-			setState(1058);
-			switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
+			setState(1055);
+			switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(1055);
+				setState(1052);
 				normalAnnotation();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(1056);
+				setState(1053);
 				markerAnnotation();
 				}
 				break;
 			case 3:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(1057);
+				setState(1054);
 				singleElementAnnotation();
 				}
 				break;
@@ -7525,22 +7477,22 @@ public final NormalAnnotationContext normalAnnotation() throws RecognitionExcept
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1060);
+			setState(1057);
 			match(AT);
-			setState(1061);
+			setState(1058);
 			typeName();
-			setState(1062);
+			setState(1059);
 			match(LPAREN);
-			setState(1064);
+			setState(1061);
 			_la = _input.LA(1);
 			if (_la==Identifier) {
 				{
-				setState(1063);
+				setState(1060);
 				elementValuePairList();
 				}
 			}
 
-			setState(1066);
+			setState(1063);
 			match(RPAREN);
 			}
 		}
@@ -7588,21 +7540,21 @@ public final ElementValuePairListContext elementValuePairList() throws Recogniti
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1068);
+			setState(1065);
 			elementValuePair();
-			setState(1073);
+			setState(1070);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==COMMA) {
 				{
 				{
-				setState(1069);
+				setState(1066);
 				match(COMMA);
-				setState(1070);
+				setState(1067);
 				elementValuePair();
 				}
 				}
-				setState(1075);
+				setState(1072);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
@@ -7649,11 +7601,11 @@ public final ElementValuePairContext elementValuePair() throws RecognitionExcept
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1076);
+			setState(1073);
 			match(Identifier);
-			setState(1077);
+			setState(1074);
 			match(ASSIGN);
-			setState(1078);
+			setState(1075);
 			elementValue();
 			}
 		}
@@ -7701,26 +7653,26 @@ public final ElementValueContext elementValue() throws RecognitionException {
 		ElementValueContext _localctx = new ElementValueContext(_ctx, getState());
 		enterRule(_localctx, 218, RULE_elementValue);
 		try {
-			setState(1083);
-			switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
+			setState(1080);
+			switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(1080);
+				setState(1077);
 				conditionalExpression();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(1081);
+				setState(1078);
 				elementValueArrayInitializer();
 				}
 				break;
 			case 3:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(1082);
+				setState(1079);
 				annotation();
 				}
 				break;
@@ -7767,27 +7719,27 @@ public final ElementValueArrayInitializerContext elementValueArrayInitializer()
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1085);
+			setState(1082);
 			match(LBRACE);
-			setState(1087);
-			switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
+			setState(1084);
+			switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
 			case 1:
 				{
-				setState(1086);
+				setState(1083);
 				elementValueList();
 				}
 				break;
 			}
-			setState(1090);
+			setState(1087);
 			_la = _input.LA(1);
 			if (_la==COMMA) {
 				{
-				setState(1089);
+				setState(1086);
 				match(COMMA);
 				}
 			}
 
-			setState(1092);
+			setState(1089);
 			match(RBRACE);
 			}
 		}
@@ -7835,25 +7787,25 @@ public final ElementValueListContext elementValueList() throws RecognitionExcept
 			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1094);
+			setState(1091);
 			elementValue();
-			setState(1099);
+			setState(1096);
 			_errHandler.sync(this);
-			_alt = getInterpreter().adaptivePredict(_input,129,_ctx);
+			_alt = getInterpreter().adaptivePredict(_input,128,_ctx);
 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 				if ( _alt==1 ) {
 					{
 					{
-					setState(1095);
+					setState(1092);
 					match(COMMA);
-					setState(1096);
+					setState(1093);
 					elementValue();
 					}
 					} 
 				}
-				setState(1101);
+				setState(1098);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,129,_ctx);
+				_alt = getInterpreter().adaptivePredict(_input,128,_ctx);
 			}
 			}
 		}
@@ -7897,9 +7849,9 @@ public final MarkerAnnotationContext markerAnnotation() throws RecognitionExcept
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1102);
+			setState(1099);
 			match(AT);
-			setState(1103);
+			setState(1100);
 			typeName();
 			}
 		}
@@ -7946,15 +7898,15 @@ public final SingleElementAnnotationContext singleElementAnnotation() throws Rec
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1105);
+			setState(1102);
 			match(AT);
-			setState(1106);
+			setState(1103);
 			typeName();
-			setState(1107);
+			setState(1104);
 			match(LPAREN);
-			setState(1108);
+			setState(1105);
 			elementValue();
-			setState(1109);
+			setState(1106);
 			match(RPAREN);
 			}
 		}
@@ -7999,27 +7951,27 @@ public final ArrayInitializerContext arrayInitializer() throws RecognitionExcept
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1111);
+			setState(1108);
 			match(LBRACE);
-			setState(1113);
-			switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
+			setState(1110);
+			switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
 			case 1:
 				{
-				setState(1112);
+				setState(1109);
 				variableInitializerList();
 				}
 				break;
 			}
-			setState(1116);
+			setState(1113);
 			_la = _input.LA(1);
 			if (_la==COMMA) {
 				{
-				setState(1115);
+				setState(1112);
 				match(COMMA);
 				}
 			}
 
-			setState(1118);
+			setState(1115);
 			match(RBRACE);
 			}
 		}
@@ -8067,25 +8019,25 @@ public final VariableInitializerListContext variableInitializerList() throws Rec
 			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1120);
+			setState(1117);
 			variableInitializer();
-			setState(1125);
+			setState(1122);
 			_errHandler.sync(this);
-			_alt = getInterpreter().adaptivePredict(_input,132,_ctx);
+			_alt = getInterpreter().adaptivePredict(_input,131,_ctx);
 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 				if ( _alt==1 ) {
 					{
 					{
-					setState(1121);
+					setState(1118);
 					match(COMMA);
-					setState(1122);
+					setState(1119);
 					variableInitializer();
 					}
 					} 
 				}
-				setState(1127);
+				setState(1124);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,132,_ctx);
+				_alt = getInterpreter().adaptivePredict(_input,131,_ctx);
 			}
 			}
 		}
@@ -8129,11 +8081,11 @@ public final BlockContext block() throws RecognitionException {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1128);
+			setState(1125);
 			match(LBRACE);
-			setState(1129);
+			setState(1126);
 			blockStatements();
-			setState(1130);
+			setState(1127);
 			match(RBRACE);
 			}
 		}
@@ -8175,21 +8127,21 @@ public final BlockStatementsContext blockStatements() throws RecognitionExceptio
 			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(1135);
+			setState(1132);
 			_errHandler.sync(this);
-			_alt = getInterpreter().adaptivePredict(_input,133,_ctx);
+			_alt = getInterpreter().adaptivePredict(_input,132,_ctx);
 			while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 				if ( _alt==1+1 ) {
 					{
 					{
-					setState(1132);
+					setState(1129);
 					matchWildcard();
 					}
 					} 
 				}
-				setState(1137);
+				setState(1134);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,133,_ctx);
+				_alt = getInterpreter().adaptivePredict(_input,132,_ctx);
 			}
 			}
 		}
@@ -8220,7 +8172,7 @@ private boolean packageOrTypeName_sempred(PackageOrTypeNameContext _localctx, in
 	}
 
 	public static final String _serializedATN =
-		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3m\u0475\4\2\t\2\4"+
+		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3m\u0472\4\2\t\2\4"+
 		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
 		"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
 		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
@@ -8289,162 +8241,161 @@ private boolean packageOrTypeName_sempred(PackageOrTypeNameContext _localctx, in
 		"\n`\f`\16`\u03c2\13`\3`\3`\3`\5`\u03c7\n`\3`\5`\u03ca\n`\3`\3`\3a\3a\3"+
 		"a\3a\3a\3a\3a\5a\u03d5\na\3b\3b\3b\3c\3c\7c\u03dc\nc\fc\16c\u03df\13c"+
 		"\3c\3c\3d\3d\3d\3d\3d\5d\u03e8\nd\3e\7e\u03eb\ne\fe\16e\u03ee\13e\3e\3"+
-		"e\6e\u03f2\ne\re\16e\u03f3\3e\3e\3f\3f\3f\3f\5f\u03fc\nf\3g\7g\u03ff\n"+
-		"g\fg\16g\u0402\13g\3g\3g\3g\3h\3h\3h\3h\3h\3h\5h\u040d\nh\3i\7i\u0410"+
-		"\ni\fi\16i\u0413\13i\3i\3i\3i\3i\3i\3j\3j\6j\u041c\nj\rj\16j\u041d\3j"+
-		"\3j\3k\3k\3k\5k\u0425\nk\3l\3l\3l\3l\5l\u042b\nl\3l\3l\3m\3m\3m\7m\u0432"+
-		"\nm\fm\16m\u0435\13m\3n\3n\3n\3n\3o\3o\3o\5o\u043e\no\3p\3p\5p\u0442\n"+
-		"p\3p\5p\u0445\np\3p\3p\3q\3q\3q\7q\u044c\nq\fq\16q\u044f\13q\3r\3r\3r"+
-		"\3s\3s\3s\3s\3s\3s\3t\3t\5t\u045c\nt\3t\5t\u045f\nt\3t\3t\3u\3u\3u\7u"+
-		"\u0466\nu\fu\16u\u0469\13u\3v\3v\3v\3v\3w\7w\u0470\nw\fw\16w\u0473\13"+
-		"w\3w\7\u03b2\u03b7\u03f3\u041d\u0471\3\64x\2\4\6\b\n\f\16\20\22\24\26"+
-		"\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|"+
-		"~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096"+
-		"\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae"+
-		"\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6"+
-		"\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de"+
-		"\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\2\4\7\2\7\7\n\n\35\35\37\37"+
-		"\'\'\4\2\20\20\26\26\u04b6\2\u00fc\3\2\2\2\4\u0100\3\2\2\2\6\u0102\3\2"+
-		"\2\2\b\u0104\3\2\2\2\n\u0109\3\2\2\2\f\u010d\3\2\2\2\16\u012c\3\2\2\2"+
-		"\20\u012e\3\2\2\2\22\u013c\3\2\2\2\24\u0143\3\2\2\2\26\u0145\3\2\2\2\30"+
-		"\u0147\3\2\2\2\32\u014c\3\2\2\2\34\u015a\3\2\2\2\36\u015f\3\2\2\2 \u0174"+
-		"\3\2\2\2\"\u017b\3\2\2\2$\u0187\3\2\2\2&\u0189\3\2\2\2(\u018c\3\2\2\2"+
-		"*\u0190\3\2\2\2,\u019a\3\2\2\2.\u019f\3\2\2\2\60\u01aa\3\2\2\2\62\u01b1"+
-		"\3\2\2\2\64\u01b3\3\2\2\2\66\u01bf\3\2\2\28\u01d2\3\2\2\2:\u01e0\3\2\2"+
-		"\2<\u01e6\3\2\2\2>\u01e8\3\2\2\2@\u01ec\3\2\2\2B\u01f2\3\2\2\2D\u01f9"+
-		"\3\2\2\2F\u0203\3\2\2\2H\u0207\3\2\2\2J\u020c\3\2\2\2L\u0224\3\2\2\2N"+
-		"\u0226\3\2\2\2P\u022a\3\2\2\2R\u0232\3\2\2\2T\u0235\3\2\2\2V\u0238\3\2"+
-		"\2\2X\u0240\3\2\2\2Z\u024d\3\2\2\2\\\u0254\3\2\2\2^\u0259\3\2\2\2`\u0268"+
-		"\3\2\2\2b\u026a\3\2\2\2d\u0272\3\2\2\2f\u0277\3\2\2\2h\u027d\3\2\2\2j"+
-		"\u0281\3\2\2\2l\u0285\3\2\2\2n\u028a\3\2\2\2p\u028e\3\2\2\2r\u0297\3\2"+
-		"\2\2t\u02a2\3\2\2\2v\u02a6\3\2\2\2x\u02a8\3\2\2\2z\u02aa\3\2\2\2|\u02b5"+
-		"\3\2\2\2~\u02ba\3\2\2\2\u0080\u02ca\3\2\2\2\u0082\u02dd\3\2\2\2\u0084"+
-		"\u02e1\3\2\2\2\u0086\u02e3\3\2\2\2\u0088\u02f1\3\2\2\2\u008a\u0303\3\2"+
-		"\2\2\u008c\u0308\3\2\2\2\u008e\u0310\3\2\2\2\u0090\u0323\3\2\2\2\u0092"+
-		"\u0328\3\2\2\2\u0094\u0332\3\2\2\2\u0096\u0335\3\2\2\2\u0098\u033f\3\2"+
-		"\2\2\u009a\u0343\3\2\2\2\u009c\u0345\3\2\2\2\u009e\u0347\3\2\2\2\u00a0"+
-		"\u034d\3\2\2\2\u00a2\u035a\3\2\2\2\u00a4\u035d\3\2\2\2\u00a6\u0366\3\2"+
-		"\2\2\u00a8\u0368\3\2\2\2\u00aa\u036f\3\2\2\2\u00ac\u0379\3\2\2\2\u00ae"+
-		"\u0385\3\2\2\2\u00b0\u0390\3\2\2\2\u00b2\u039e\3\2\2\2\u00b4\u03a0\3\2"+
-		"\2\2\u00b6\u03a7\3\2\2\2\u00b8\u03b0\3\2\2\2\u00ba\u03b5\3\2\2\2\u00bc"+
-		"\u03bb\3\2\2\2\u00be\u03c0\3\2\2\2\u00c0\u03d4\3\2\2\2\u00c2\u03d6\3\2"+
-		"\2\2\u00c4\u03d9\3\2\2\2\u00c6\u03e7\3\2\2\2\u00c8\u03ec\3\2\2\2\u00ca"+
-		"\u03fb\3\2\2\2\u00cc\u0400\3\2\2\2\u00ce\u040c\3\2\2\2\u00d0\u0411\3\2"+
-		"\2\2\u00d2\u0419\3\2\2\2\u00d4\u0424\3\2\2\2\u00d6\u0426\3\2\2\2\u00d8"+
-		"\u042e\3\2\2\2\u00da\u0436\3\2\2\2\u00dc\u043d\3\2\2\2\u00de\u043f\3\2"+
-		"\2\2\u00e0\u0448\3\2\2\2\u00e2\u0450\3\2\2\2\u00e4\u0453\3\2\2\2\u00e6"+
-		"\u0459\3\2\2\2\u00e8\u0462\3\2\2\2\u00ea\u046a\3\2\2\2\u00ec\u0471\3\2"+
-		"\2\2\u00ee\u00f0\5\u00d4k\2\u00ef\u00ee\3\2\2\2\u00f0\u00f3\3\2\2\2\u00f1"+
-		"\u00ef\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2\u00f4\3\2\2\2\u00f3\u00f1\3\2"+
-		"\2\2\u00f4\u00fd\5\4\3\2\u00f5\u00f7\5\u00d4k\2\u00f6\u00f5\3\2\2\2\u00f7"+
-		"\u00fa\3\2\2\2\u00f8\u00f6\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9\u00fb\3\2"+
-		"\2\2\u00fa\u00f8\3\2\2\2\u00fb\u00fd\7\5\2\2\u00fc\u00f1\3\2\2\2\u00fc"+
-		"\u00f8\3\2\2\2\u00fd\3\3\2\2\2\u00fe\u0101\5\6\4\2\u00ff\u0101\5\b\5\2"+
-		"\u0100\u00fe\3\2\2\2\u0100\u00ff\3\2\2\2\u0101\5\3\2\2\2\u0102\u0103\t"+
-		"\2\2\2\u0103\7\3\2\2\2\u0104\u0105\t\3\2\2\u0105\t\3\2\2\2\u0106\u010a"+
-		"\5\f\7\2\u0107\u010a\5\32\16\2\u0108\u010a\5\34\17\2\u0109\u0106\3\2\2"+
-		"\2\u0109\u0107\3\2\2\2\u0109\u0108\3\2\2\2\u010a\13\3\2\2\2\u010b\u010e"+
-		"\5\22\n\2\u010c\u010e\5\30\r\2\u010d\u010b\3\2\2\2\u010d\u010c\3\2\2\2"+
-		"\u010e\u0113\3\2\2\2\u010f\u0112\5\20\t\2\u0110\u0112\5\26\f\2\u0111\u010f"+
-		"\3\2\2\2\u0111\u0110\3\2\2\2\u0112\u0115\3\2\2\2\u0113\u0111\3\2\2\2\u0113"+
-		"\u0114\3\2\2\2\u0114\r\3\2\2\2\u0115\u0113\3\2\2\2\u0116\u0118\5\u00d4"+
-		"k\2\u0117\u0116\3\2\2\2\u0118\u011b\3\2\2\2\u0119\u0117\3\2\2\2\u0119"+
-		"\u011a\3\2\2\2\u011a\u011c\3\2\2\2\u011b\u0119\3\2\2\2\u011c\u011e\7h"+
-		"\2\2\u011d\u011f\5(\25\2\u011e\u011d\3\2\2\2\u011e\u011f\3\2\2\2\u011f"+
-		"\u012d\3\2\2\2\u0120\u0121\5\f\7\2\u0121\u0125\7C\2\2\u0122\u0124\5\u00d4"+
-		"k\2\u0123\u0122\3\2\2\2\u0124\u0127\3\2\2\2\u0125\u0123\3\2\2\2\u0125"+
-		"\u0126\3\2\2\2\u0126\u0128\3\2\2\2\u0127\u0125\3\2\2\2\u0128\u012a\7h"+
-		"\2\2\u0129\u012b\5(\25\2\u012a\u0129\3\2\2\2\u012a\u012b\3\2\2\2\u012b"+
-		"\u012d\3\2\2\2\u012c\u0119\3\2\2\2\u012c\u0120\3\2\2\2\u012d\17\3\2\2"+
-		"\2\u012e\u0132\7C\2\2\u012f\u0131\5\u00d4k\2\u0130\u012f\3\2\2\2\u0131"+
-		"\u0134\3\2\2\2\u0132\u0130\3\2\2\2\u0132\u0133\3\2\2\2\u0133\u0135\3\2"+
-		"\2\2\u0134\u0132\3\2\2\2\u0135\u0137\7h\2\2\u0136\u0138\5(\25\2\u0137"+
-		"\u0136\3\2\2\2\u0137\u0138\3\2\2\2\u0138\21\3\2\2\2\u0139\u013b\5\u00d4"+
-		"k\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c"+
-		"\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0141\7h"+
-		"\2\2\u0140\u0142\5(\25\2\u0141\u0140\3\2\2\2\u0141\u0142\3\2\2\2\u0142"+
-		"\23\3\2\2\2\u0143\u0144\5\16\b\2\u0144\25\3\2\2\2\u0145\u0146\5\20\t\2"+
-		"\u0146\27\3\2\2\2\u0147\u0148\5\22\n\2\u0148\31\3\2\2\2\u0149\u014b\5"+
-		"\u00d4k\2\u014a\u0149\3\2\2\2\u014b\u014e\3\2\2\2\u014c\u014a\3\2\2\2"+
-		"\u014c\u014d\3\2\2\2\u014d\u014f\3\2\2\2\u014e\u014c\3\2\2\2\u014f\u0150"+
-		"\7h\2\2\u0150\33\3\2\2\2\u0151\u0152\5\2\2\2\u0152\u0153\5\36\20\2\u0153"+
-		"\u015b\3\2\2\2\u0154\u0155\5\f\7\2\u0155\u0156\5\36\20\2\u0156\u015b\3"+
-		"\2\2\2\u0157\u0158\5\32\16\2\u0158\u0159\5\36\20\2\u0159\u015b\3\2\2\2"+
-		"\u015a\u0151\3\2\2\2\u015a\u0154\3\2\2\2\u015a\u0157\3\2\2\2\u015b\35"+
-		"\3\2\2\2\u015c\u015e\5\u00d4k\2\u015d\u015c\3\2\2\2\u015e\u0161\3\2\2"+
-		"\2\u015f\u015d\3\2\2\2\u015f\u0160\3\2\2\2\u0160\u0162\3\2\2\2\u0161\u015f"+
-		"\3\2\2\2\u0162\u0163\7?\2\2\u0163\u016e\7@\2\2\u0164\u0166\5\u00d4k\2"+
-		"\u0165\u0164\3\2\2\2\u0166\u0169\3\2\2\2\u0167\u0165\3\2\2\2\u0167\u0168"+
-		"\3\2\2\2\u0168\u016a\3\2\2\2\u0169\u0167\3\2\2\2\u016a\u016b\7?\2\2\u016b"+
-		"\u016d\7@\2\2\u016c\u0167\3\2\2\2\u016d\u0170\3\2\2\2\u016e\u016c\3\2"+
-		"\2\2\u016e\u016f\3\2\2\2\u016f\37\3\2\2\2\u0170\u016e\3\2\2\2\u0171\u0173"+
-		"\5\"\22\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2\2\2"+
-		"\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2\u0177\u0179"+
-		"\7h\2\2\u0178\u017a\5$\23\2\u0179\u0178\3\2\2\2\u0179\u017a\3\2\2\2\u017a"+
-		"!\3\2\2\2\u017b\u017c\5\u00d4k\2\u017c#\3\2\2\2\u017d\u017e\7\23\2\2\u017e"+
-		"\u0188\5\32\16\2\u017f\u0180\7\23\2\2\u0180\u0184\5\f\7\2\u0181\u0183"+
-		"\5&\24\2\u0182\u0181\3\2\2\2\u0183\u0186\3\2\2\2\u0184\u0182\3\2\2\2\u0184"+
-		"\u0185\3\2\2\2\u0185\u0188\3\2\2\2\u0186\u0184\3\2\2\2\u0187\u017d\3\2"+
-		"\2\2\u0187\u017f\3\2\2\2\u0188%\3\2\2\2\u0189\u018a\7W\2\2\u018a\u018b"+
-		"\5\24\13\2\u018b\'\3\2\2\2\u018c\u018d\7F\2\2\u018d\u018e\5*\26\2\u018e"+
-		"\u018f\7E\2\2\u018f)\3\2\2\2\u0190\u0195\5,\27\2\u0191\u0192\7B\2\2\u0192"+
-		"\u0194\5,\27\2\u0193\u0191\3\2\2\2\u0194\u0197\3\2\2\2\u0195\u0193\3\2"+
-		"\2\2\u0195\u0196\3\2\2\2\u0196+\3\2\2\2\u0197\u0195\3\2\2\2\u0198\u019b"+
-		"\5\n\6\2\u0199\u019b\5.\30\2\u019a\u0198\3\2\2\2\u019a\u0199\3\2\2\2\u019b"+
-		"-\3\2\2\2\u019c\u019e\5\u00d4k\2\u019d\u019c\3\2\2\2\u019e\u01a1\3\2\2"+
-		"\2\u019f\u019d\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a2\3\2\2\2\u01a1\u019f"+
-		"\3\2\2\2\u01a2\u01a4\7I\2\2\u01a3\u01a5\5\60\31\2\u01a4\u01a3\3\2\2\2"+
-		"\u01a4\u01a5\3\2\2\2\u01a5/\3\2\2\2\u01a6\u01a7\7\23\2\2\u01a7\u01ab\5"+
-		"\n\6\2\u01a8\u01a9\7*\2\2\u01a9\u01ab\5\n\6\2\u01aa\u01a6\3\2\2\2\u01aa"+
-		"\u01a8\3\2\2\2\u01ab\61\3\2\2\2\u01ac\u01b2\7h\2\2\u01ad\u01ae\5\64\33"+
-		"\2\u01ae\u01af\7C\2\2\u01af\u01b0\7h\2\2\u01b0\u01b2\3\2\2\2\u01b1\u01ac"+
-		"\3\2\2\2\u01b1\u01ad\3\2\2\2\u01b2\63\3\2\2\2\u01b3\u01b4\b\33\1\2\u01b4"+
-		"\u01b5\7h\2\2\u01b5\u01bb\3\2\2\2\u01b6\u01b7\f\3\2\2\u01b7\u01b8\7C\2"+
-		"\2\u01b8\u01ba\7h\2\2\u01b9\u01b6\3\2\2\2\u01ba\u01bd\3\2\2\2\u01bb\u01b9"+
-		"\3\2\2\2\u01bb\u01bc\3\2\2\2\u01bc\65\3\2\2\2\u01bd\u01bb\3\2\2\2\u01be"+
-		"\u01c0\58\35\2\u01bf\u01be\3\2\2\2\u01bf\u01c0\3\2\2\2\u01c0\u01c4\3\2"+
-		"\2\2\u01c1\u01c3\5<\37\2\u01c2\u01c1\3\2\2\2\u01c3\u01c6\3\2\2\2\u01c4"+
-		"\u01c2\3\2\2\2\u01c4\u01c5\3\2\2\2\u01c5\u01ca\3\2\2\2\u01c6\u01c4\3\2"+
-		"\2\2\u01c7\u01c9\5F$\2\u01c8\u01c7\3\2\2\2\u01c9\u01cc\3\2\2\2\u01ca\u01c8"+
-		"\3\2\2\2\u01ca\u01cb\3\2\2\2\u01cb\u01cd\3\2\2\2\u01cc\u01ca\3\2\2\2\u01cd"+
-		"\u01ce\7\2\2\3\u01ce\67\3\2\2\2\u01cf\u01d1\5:\36\2\u01d0\u01cf\3\2\2"+
-		"\2\u01d1\u01d4\3\2\2\2\u01d2\u01d0\3\2\2\2\u01d2\u01d3\3\2\2\2\u01d3\u01d5"+
-		"\3\2\2\2\u01d4\u01d2\3\2\2\2\u01d5\u01d6\7\"\2\2\u01d6\u01db\7h\2\2\u01d7"+
-		"\u01d8\7C\2\2\u01d8\u01da\7h\2\2\u01d9\u01d7\3\2\2\2\u01da\u01dd\3\2\2"+
-		"\2\u01db\u01d9\3\2\2\2\u01db\u01dc\3\2\2\2\u01dc\u01de\3\2\2\2\u01dd\u01db"+
-		"\3\2\2\2\u01de\u01df\7A\2\2\u01df9\3\2\2\2\u01e0\u01e1\5\u00d4k\2\u01e1"+
-		";\3\2\2\2\u01e2\u01e7\5> \2\u01e3\u01e7\5@!\2\u01e4\u01e7\5B\"\2\u01e5"+
-		"\u01e7\5D#\2\u01e6\u01e2\3\2\2\2\u01e6\u01e3\3\2\2\2\u01e6\u01e4\3\2\2"+
-		"\2\u01e6\u01e5\3\2\2\2\u01e7=\3\2\2\2\u01e8\u01e9\7\33\2\2\u01e9\u01ea"+
-		"\5\62\32\2\u01ea\u01eb\7A\2\2\u01eb?\3\2\2\2\u01ec\u01ed\7\33\2\2\u01ed"+
-		"\u01ee\5\64\33\2\u01ee\u01ef\7C\2\2\u01ef\u01f0\7U\2\2\u01f0\u01f1\7A"+
-		"\2\2\u01f1A\3\2\2\2\u01f2\u01f3\7\33\2\2\u01f3\u01f4\7(\2\2\u01f4\u01f5"+
-		"\5\62\32\2\u01f5\u01f6\7C\2\2\u01f6\u01f7\7h\2\2\u01f7\u01f8\7A\2\2\u01f8"+
-		"C\3\2\2\2\u01f9\u01fa\7\33\2\2\u01fa\u01fb\7(\2\2\u01fb\u01fc\5\62\32"+
-		"\2\u01fc\u01fd\7C\2\2\u01fd\u01fe\7U\2\2\u01fe\u01ff\7A\2\2\u01ffE\3\2"+
-		"\2\2\u0200\u0204\5H%\2\u0201\u0204\5\u00bc_\2\u0202\u0204\7A\2\2\u0203"+
-		"\u0200\3\2\2\2\u0203\u0201\3\2\2\2\u0203\u0202\3\2\2\2\u0204G\3\2\2\2"+
-		"\u0205\u0208\5J&\2\u0206\u0208\5\u00aaV\2\u0207\u0205\3\2\2\2\u0207\u0206"+
-		"\3\2\2\2\u0208I\3\2\2\2\u0209\u020b\5L\'\2\u020a\u0209\3\2\2\2\u020b\u020e"+
-		"\3\2\2\2\u020c\u020a\3\2\2\2\u020c\u020d\3\2\2\2\u020d\u020f\3\2\2\2\u020e"+
-		"\u020c\3\2\2\2\u020f\u0210\7\13\2\2\u0210\u0212\7h\2\2\u0211\u0213\5N"+
-		"(\2\u0212\u0211\3\2\2\2\u0212\u0213\3\2\2\2\u0213\u0215\3\2\2\2\u0214"+
-		"\u0216\5R*\2\u0215\u0214\3\2\2\2\u0215\u0216\3\2\2\2\u0216\u0218\3\2\2"+
-		"\2\u0217\u0219\5T+\2\u0218\u0217\3\2\2\2\u0218\u0219\3\2\2\2\u0219\u021a"+
-		"\3\2\2\2\u021a\u021b\5X-\2\u021bK\3\2\2\2\u021c\u0225\5\u00d4k\2\u021d"+
-		"\u0225\7%\2\2\u021e\u0225\7$\2\2\u021f\u0225\7#\2\2\u0220\u0225\7\3\2"+
-		"\2\u0221\u0225\7(\2\2\u0222\u0225\7\24\2\2\u0223\u0225\7)\2\2\u0224\u021c"+
-		"\3\2\2\2\u0224\u021d\3\2\2\2\u0224\u021e\3\2\2\2\u0224\u021f\3\2\2\2\u0224"+
-		"\u0220\3\2\2\2\u0224\u0221\3\2\2\2\u0224\u0222\3\2\2\2\u0224\u0223\3\2"+
-		"\2\2\u0225M\3\2\2\2\u0226\u0227\7F\2\2\u0227\u0228\5P)\2\u0228\u0229\7"+
-		"E\2\2\u0229O\3\2\2\2\u022a\u022f\5 \21\2\u022b\u022c\7B\2\2\u022c\u022e"+
-		"\5 \21\2\u022d\u022b\3\2\2\2\u022e\u0231\3\2\2\2\u022f\u022d\3\2\2\2\u022f"+
-		"\u0230\3\2\2\2\u0230Q\3\2\2\2\u0231\u022f\3\2\2\2\u0232\u0233\7\23\2\2"+
-		"\u0233\u0234\5\16\b\2\u0234S\3\2\2\2\u0235\u0236\7\32\2\2\u0236\u0237"+
-		"\5V,\2\u0237U\3\2\2\2\u0238\u023d\5\24\13\2\u0239\u023a\7B\2\2\u023a\u023c"+
-		"\5\24\13\2\u023b\u0239\3\2\2\2\u023c\u023f\3\2\2\2\u023d\u023b\3\2\2\2"+
-		"\u023d\u023e\3\2\2\2\u023eW\3\2\2\2\u023f\u023d\3\2\2\2\u0240\u0244\7"+
-		"=\2\2\u0241\u0243\5Z.\2\u0242\u0241\3\2\2\2\u0243\u0246\3\2\2\2\u0244"+
+		"e\3e\3e\3f\3f\3f\3f\5f\u03f8\nf\3g\7g\u03fb\ng\fg\16g\u03fe\13g\3g\3g"+
+		"\3g\3h\3h\3h\3h\3h\3h\5h\u0409\nh\3i\7i\u040c\ni\fi\16i\u040f\13i\3i\3"+
+		"i\3i\3i\3i\3j\3j\7j\u0418\nj\fj\16j\u041b\13j\3j\3j\3k\3k\3k\5k\u0422"+
+		"\nk\3l\3l\3l\3l\5l\u0428\nl\3l\3l\3m\3m\3m\7m\u042f\nm\fm\16m\u0432\13"+
+		"m\3n\3n\3n\3n\3o\3o\3o\5o\u043b\no\3p\3p\5p\u043f\np\3p\5p\u0442\np\3"+
+		"p\3p\3q\3q\3q\7q\u0449\nq\fq\16q\u044c\13q\3r\3r\3r\3s\3s\3s\3s\3s\3s"+
+		"\3t\3t\5t\u0459\nt\3t\5t\u045c\nt\3t\3t\3u\3u\3u\7u\u0463\nu\fu\16u\u0466"+
+		"\13u\3v\3v\3v\3v\3w\7w\u046d\nw\fw\16w\u0470\13w\3w\6\u03b2\u03b7\u0419"+
+		"\u046e\3\64x\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64"+
+		"\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088"+
+		"\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0"+
+		"\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8"+
+		"\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0"+
+		"\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8"+
+		"\u00ea\u00ec\2\4\7\2\7\7\n\n\35\35\37\37\'\'\4\2\20\20\26\26\u04b2\2\u00fc"+
+		"\3\2\2\2\4\u0100\3\2\2\2\6\u0102\3\2\2\2\b\u0104\3\2\2\2\n\u0109\3\2\2"+
+		"\2\f\u010d\3\2\2\2\16\u012c\3\2\2\2\20\u012e\3\2\2\2\22\u013c\3\2\2\2"+
+		"\24\u0143\3\2\2\2\26\u0145\3\2\2\2\30\u0147\3\2\2\2\32\u014c\3\2\2\2\34"+
+		"\u015a\3\2\2\2\36\u015f\3\2\2\2 \u0174\3\2\2\2\"\u017b\3\2\2\2$\u0187"+
+		"\3\2\2\2&\u0189\3\2\2\2(\u018c\3\2\2\2*\u0190\3\2\2\2,\u019a\3\2\2\2."+
+		"\u019f\3\2\2\2\60\u01aa\3\2\2\2\62\u01b1\3\2\2\2\64\u01b3\3\2\2\2\66\u01bf"+
+		"\3\2\2\28\u01d2\3\2\2\2:\u01e0\3\2\2\2<\u01e6\3\2\2\2>\u01e8\3\2\2\2@"+
+		"\u01ec\3\2\2\2B\u01f2\3\2\2\2D\u01f9\3\2\2\2F\u0203\3\2\2\2H\u0207\3\2"+
+		"\2\2J\u020c\3\2\2\2L\u0224\3\2\2\2N\u0226\3\2\2\2P\u022a\3\2\2\2R\u0232"+
+		"\3\2\2\2T\u0235\3\2\2\2V\u0238\3\2\2\2X\u0240\3\2\2\2Z\u024d\3\2\2\2\\"+
+		"\u0254\3\2\2\2^\u0259\3\2\2\2`\u0268\3\2\2\2b\u026a\3\2\2\2d\u0272\3\2"+
+		"\2\2f\u0277\3\2\2\2h\u027d\3\2\2\2j\u0281\3\2\2\2l\u0285\3\2\2\2n\u028a"+
+		"\3\2\2\2p\u028e\3\2\2\2r\u0297\3\2\2\2t\u02a2\3\2\2\2v\u02a6\3\2\2\2x"+
+		"\u02a8\3\2\2\2z\u02aa\3\2\2\2|\u02b5\3\2\2\2~\u02ba\3\2\2\2\u0080\u02ca"+
+		"\3\2\2\2\u0082\u02dd\3\2\2\2\u0084\u02e1\3\2\2\2\u0086\u02e3\3\2\2\2\u0088"+
+		"\u02f1\3\2\2\2\u008a\u0303\3\2\2\2\u008c\u0308\3\2\2\2\u008e\u0310\3\2"+
+		"\2\2\u0090\u0323\3\2\2\2\u0092\u0328\3\2\2\2\u0094\u0332\3\2\2\2\u0096"+
+		"\u0335\3\2\2\2\u0098\u033f\3\2\2\2\u009a\u0343\3\2\2\2\u009c\u0345\3\2"+
+		"\2\2\u009e\u0347\3\2\2\2\u00a0\u034d\3\2\2\2\u00a2\u035a\3\2\2\2\u00a4"+
+		"\u035d\3\2\2\2\u00a6\u0366\3\2\2\2\u00a8\u0368\3\2\2\2\u00aa\u036f\3\2"+
+		"\2\2\u00ac\u0379\3\2\2\2\u00ae\u0385\3\2\2\2\u00b0\u0390\3\2\2\2\u00b2"+
+		"\u039e\3\2\2\2\u00b4\u03a0\3\2\2\2\u00b6\u03a7\3\2\2\2\u00b8\u03b0\3\2"+
+		"\2\2\u00ba\u03b5\3\2\2\2\u00bc\u03bb\3\2\2\2\u00be\u03c0\3\2\2\2\u00c0"+
+		"\u03d4\3\2\2\2\u00c2\u03d6\3\2\2\2\u00c4\u03d9\3\2\2\2\u00c6\u03e7\3\2"+
+		"\2\2\u00c8\u03ec\3\2\2\2\u00ca\u03f7\3\2\2\2\u00cc\u03fc\3\2\2\2\u00ce"+
+		"\u0408\3\2\2\2\u00d0\u040d\3\2\2\2\u00d2\u0415\3\2\2\2\u00d4\u0421\3\2"+
+		"\2\2\u00d6\u0423\3\2\2\2\u00d8\u042b\3\2\2\2\u00da\u0433\3\2\2\2\u00dc"+
+		"\u043a\3\2\2\2\u00de\u043c\3\2\2\2\u00e0\u0445\3\2\2\2\u00e2\u044d\3\2"+
+		"\2\2\u00e4\u0450\3\2\2\2\u00e6\u0456\3\2\2\2\u00e8\u045f\3\2\2\2\u00ea"+
+		"\u0467\3\2\2\2\u00ec\u046e\3\2\2\2\u00ee\u00f0\5\u00d4k\2\u00ef\u00ee"+
+		"\3\2\2\2\u00f0\u00f3\3\2\2\2\u00f1\u00ef\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2"+
+		"\u00f4\3\2\2\2\u00f3\u00f1\3\2\2\2\u00f4\u00fd\5\4\3\2\u00f5\u00f7\5\u00d4"+
+		"k\2\u00f6\u00f5\3\2\2\2\u00f7\u00fa\3\2\2\2\u00f8\u00f6\3\2\2\2\u00f8"+
+		"\u00f9\3\2\2\2\u00f9\u00fb\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fb\u00fd\7\5"+
+		"\2\2\u00fc\u00f1\3\2\2\2\u00fc\u00f8\3\2\2\2\u00fd\3\3\2\2\2\u00fe\u0101"+
+		"\5\6\4\2\u00ff\u0101\5\b\5\2\u0100\u00fe\3\2\2\2\u0100\u00ff\3\2\2\2\u0101"+
+		"\5\3\2\2\2\u0102\u0103\t\2\2\2\u0103\7\3\2\2\2\u0104\u0105\t\3\2\2\u0105"+
+		"\t\3\2\2\2\u0106\u010a\5\f\7\2\u0107\u010a\5\32\16\2\u0108\u010a\5\34"+
+		"\17\2\u0109\u0106\3\2\2\2\u0109\u0107\3\2\2\2\u0109\u0108\3\2\2\2\u010a"+
+		"\13\3\2\2\2\u010b\u010e\5\22\n\2\u010c\u010e\5\30\r\2\u010d\u010b\3\2"+
+		"\2\2\u010d\u010c\3\2\2\2\u010e\u0113\3\2\2\2\u010f\u0112\5\20\t\2\u0110"+
+		"\u0112\5\26\f\2\u0111\u010f\3\2\2\2\u0111\u0110\3\2\2\2\u0112\u0115\3"+
+		"\2\2\2\u0113\u0111\3\2\2\2\u0113\u0114\3\2\2\2\u0114\r\3\2\2\2\u0115\u0113"+
+		"\3\2\2\2\u0116\u0118\5\u00d4k\2\u0117\u0116\3\2\2\2\u0118\u011b\3\2\2"+
+		"\2\u0119\u0117\3\2\2\2\u0119\u011a\3\2\2\2\u011a\u011c\3\2\2\2\u011b\u0119"+
+		"\3\2\2\2\u011c\u011e\7h\2\2\u011d\u011f\5(\25\2\u011e\u011d\3\2\2\2\u011e"+
+		"\u011f\3\2\2\2\u011f\u012d\3\2\2\2\u0120\u0121\5\f\7\2\u0121\u0125\7C"+
+		"\2\2\u0122\u0124\5\u00d4k\2\u0123\u0122\3\2\2\2\u0124\u0127\3\2\2\2\u0125"+
+		"\u0123\3\2\2\2\u0125\u0126\3\2\2\2\u0126\u0128\3\2\2\2\u0127\u0125\3\2"+
+		"\2\2\u0128\u012a\7h\2\2\u0129\u012b\5(\25\2\u012a\u0129\3\2\2\2\u012a"+
+		"\u012b\3\2\2\2\u012b\u012d\3\2\2\2\u012c\u0119\3\2\2\2\u012c\u0120\3\2"+
+		"\2\2\u012d\17\3\2\2\2\u012e\u0132\7C\2\2\u012f\u0131\5\u00d4k\2\u0130"+
+		"\u012f\3\2\2\2\u0131\u0134\3\2\2\2\u0132\u0130\3\2\2\2\u0132\u0133\3\2"+
+		"\2\2\u0133\u0135\3\2\2\2\u0134\u0132\3\2\2\2\u0135\u0137\7h\2\2\u0136"+
+		"\u0138\5(\25\2\u0137\u0136\3\2\2\2\u0137\u0138\3\2\2\2\u0138\21\3\2\2"+
+		"\2\u0139\u013b\5\u00d4k\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c"+
+		"\u013a\3\2\2\2\u013c\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2"+
+		"\2\2\u013f\u0141\7h\2\2\u0140\u0142\5(\25\2\u0141\u0140\3\2\2\2\u0141"+
+		"\u0142\3\2\2\2\u0142\23\3\2\2\2\u0143\u0144\5\16\b\2\u0144\25\3\2\2\2"+
+		"\u0145\u0146\5\20\t\2\u0146\27\3\2\2\2\u0147\u0148\5\22\n\2\u0148\31\3"+
+		"\2\2\2\u0149\u014b\5\u00d4k\2\u014a\u0149\3\2\2\2\u014b\u014e\3\2\2\2"+
+		"\u014c\u014a\3\2\2\2\u014c\u014d\3\2\2\2\u014d\u014f\3\2\2\2\u014e\u014c"+
+		"\3\2\2\2\u014f\u0150\7h\2\2\u0150\33\3\2\2\2\u0151\u0152\5\2\2\2\u0152"+
+		"\u0153\5\36\20\2\u0153\u015b\3\2\2\2\u0154\u0155\5\f\7\2\u0155\u0156\5"+
+		"\36\20\2\u0156\u015b\3\2\2\2\u0157\u0158\5\32\16\2\u0158\u0159\5\36\20"+
+		"\2\u0159\u015b\3\2\2\2\u015a\u0151\3\2\2\2\u015a\u0154\3\2\2\2\u015a\u0157"+
+		"\3\2\2\2\u015b\35\3\2\2\2\u015c\u015e\5\u00d4k\2\u015d\u015c\3\2\2\2\u015e"+
+		"\u0161\3\2\2\2\u015f\u015d\3\2\2\2\u015f\u0160\3\2\2\2\u0160\u0162\3\2"+
+		"\2\2\u0161\u015f\3\2\2\2\u0162\u0163\7?\2\2\u0163\u016e\7@\2\2\u0164\u0166"+
+		"\5\u00d4k\2\u0165\u0164\3\2\2\2\u0166\u0169\3\2\2\2\u0167\u0165\3\2\2"+
+		"\2\u0167\u0168\3\2\2\2\u0168\u016a\3\2\2\2\u0169\u0167\3\2\2\2\u016a\u016b"+
+		"\7?\2\2\u016b\u016d\7@\2\2\u016c\u0167\3\2\2\2\u016d\u0170\3\2\2\2\u016e"+
+		"\u016c\3\2\2\2\u016e\u016f\3\2\2\2\u016f\37\3\2\2\2\u0170\u016e\3\2\2"+
+		"\2\u0171\u0173\5\"\22\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174"+
+		"\u0172\3\2\2\2\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2"+
+		"\2\2\u0177\u0179\7h\2\2\u0178\u017a\5$\23\2\u0179\u0178\3\2\2\2\u0179"+
+		"\u017a\3\2\2\2\u017a!\3\2\2\2\u017b\u017c\5\u00d4k\2\u017c#\3\2\2\2\u017d"+
+		"\u017e\7\23\2\2\u017e\u0188\5\32\16\2\u017f\u0180\7\23\2\2\u0180\u0184"+
+		"\5\f\7\2\u0181\u0183\5&\24\2\u0182\u0181\3\2\2\2\u0183\u0186\3\2\2\2\u0184"+
+		"\u0182\3\2\2\2\u0184\u0185\3\2\2\2\u0185\u0188\3\2\2\2\u0186\u0184\3\2"+
+		"\2\2\u0187\u017d\3\2\2\2\u0187\u017f\3\2\2\2\u0188%\3\2\2\2\u0189\u018a"+
+		"\7W\2\2\u018a\u018b\5\24\13\2\u018b\'\3\2\2\2\u018c\u018d\7F\2\2\u018d"+
+		"\u018e\5*\26\2\u018e\u018f\7E\2\2\u018f)\3\2\2\2\u0190\u0195\5,\27\2\u0191"+
+		"\u0192\7B\2\2\u0192\u0194\5,\27\2\u0193\u0191\3\2\2\2\u0194\u0197\3\2"+
+		"\2\2\u0195\u0193\3\2\2\2\u0195\u0196\3\2\2\2\u0196+\3\2\2\2\u0197\u0195"+
+		"\3\2\2\2\u0198\u019b\5\n\6\2\u0199\u019b\5.\30\2\u019a\u0198\3\2\2\2\u019a"+
+		"\u0199\3\2\2\2\u019b-\3\2\2\2\u019c\u019e\5\u00d4k\2\u019d\u019c\3\2\2"+
+		"\2\u019e\u01a1\3\2\2\2\u019f\u019d\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a2"+
+		"\3\2\2\2\u01a1\u019f\3\2\2\2\u01a2\u01a4\7I\2\2\u01a3\u01a5\5\60\31\2"+
+		"\u01a4\u01a3\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5/\3\2\2\2\u01a6\u01a7\7"+
+		"\23\2\2\u01a7\u01ab\5\n\6\2\u01a8\u01a9\7*\2\2\u01a9\u01ab\5\n\6\2\u01aa"+
+		"\u01a6\3\2\2\2\u01aa\u01a8\3\2\2\2\u01ab\61\3\2\2\2\u01ac\u01b2\7h\2\2"+
+		"\u01ad\u01ae\5\64\33\2\u01ae\u01af\7C\2\2\u01af\u01b0\7h\2\2\u01b0\u01b2"+
+		"\3\2\2\2\u01b1\u01ac\3\2\2\2\u01b1\u01ad\3\2\2\2\u01b2\63\3\2\2\2\u01b3"+
+		"\u01b4\b\33\1\2\u01b4\u01b5\7h\2\2\u01b5\u01bb\3\2\2\2\u01b6\u01b7\f\3"+
+		"\2\2\u01b7\u01b8\7C\2\2\u01b8\u01ba\7h\2\2\u01b9\u01b6\3\2\2\2\u01ba\u01bd"+
+		"\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bb\u01bc\3\2\2\2\u01bc\65\3\2\2\2\u01bd"+
+		"\u01bb\3\2\2\2\u01be\u01c0\58\35\2\u01bf\u01be\3\2\2\2\u01bf\u01c0\3\2"+
+		"\2\2\u01c0\u01c4\3\2\2\2\u01c1\u01c3\5<\37\2\u01c2\u01c1\3\2\2\2\u01c3"+
+		"\u01c6\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c4\u01c5\3\2\2\2\u01c5\u01ca\3\2"+
+		"\2\2\u01c6\u01c4\3\2\2\2\u01c7\u01c9\5F$\2\u01c8\u01c7\3\2\2\2\u01c9\u01cc"+
+		"\3\2\2\2\u01ca\u01c8\3\2\2\2\u01ca\u01cb\3\2\2\2\u01cb\u01cd\3\2\2\2\u01cc"+
+		"\u01ca\3\2\2\2\u01cd\u01ce\7\2\2\3\u01ce\67\3\2\2\2\u01cf\u01d1\5:\36"+
+		"\2\u01d0\u01cf\3\2\2\2\u01d1\u01d4\3\2\2\2\u01d2\u01d0\3\2\2\2\u01d2\u01d3"+
+		"\3\2\2\2\u01d3\u01d5\3\2\2\2\u01d4\u01d2\3\2\2\2\u01d5\u01d6\7\"\2\2\u01d6"+
+		"\u01db\7h\2\2\u01d7\u01d8\7C\2\2\u01d8\u01da\7h\2\2\u01d9\u01d7\3\2\2"+
+		"\2\u01da\u01dd\3\2\2\2\u01db\u01d9\3\2\2\2\u01db\u01dc\3\2\2\2\u01dc\u01de"+
+		"\3\2\2\2\u01dd\u01db\3\2\2\2\u01de\u01df\7A\2\2\u01df9\3\2\2\2\u01e0\u01e1"+
+		"\5\u00d4k\2\u01e1;\3\2\2\2\u01e2\u01e7\5> \2\u01e3\u01e7\5@!\2\u01e4\u01e7"+
+		"\5B\"\2\u01e5\u01e7\5D#\2\u01e6\u01e2\3\2\2\2\u01e6\u01e3\3\2\2\2\u01e6"+
+		"\u01e4\3\2\2\2\u01e6\u01e5\3\2\2\2\u01e7=\3\2\2\2\u01e8\u01e9\7\33\2\2"+
+		"\u01e9\u01ea\5\62\32\2\u01ea\u01eb\7A\2\2\u01eb?\3\2\2\2\u01ec\u01ed\7"+
+		"\33\2\2\u01ed\u01ee\5\64\33\2\u01ee\u01ef\7C\2\2\u01ef\u01f0\7U\2\2\u01f0"+
+		"\u01f1\7A\2\2\u01f1A\3\2\2\2\u01f2\u01f3\7\33\2\2\u01f3\u01f4\7(\2\2\u01f4"+
+		"\u01f5\5\62\32\2\u01f5\u01f6\7C\2\2\u01f6\u01f7\7h\2\2\u01f7\u01f8\7A"+
+		"\2\2\u01f8C\3\2\2\2\u01f9\u01fa\7\33\2\2\u01fa\u01fb\7(\2\2\u01fb\u01fc"+
+		"\5\62\32\2\u01fc\u01fd\7C\2\2\u01fd\u01fe\7U\2\2\u01fe\u01ff\7A\2\2\u01ff"+
+		"E\3\2\2\2\u0200\u0204\5H%\2\u0201\u0204\5\u00bc_\2\u0202\u0204\7A\2\2"+
+		"\u0203\u0200\3\2\2\2\u0203\u0201\3\2\2\2\u0203\u0202\3\2\2\2\u0204G\3"+
+		"\2\2\2\u0205\u0208\5J&\2\u0206\u0208\5\u00aaV\2\u0207\u0205\3\2\2\2\u0207"+
+		"\u0206\3\2\2\2\u0208I\3\2\2\2\u0209\u020b\5L\'\2\u020a\u0209\3\2\2\2\u020b"+
+		"\u020e\3\2\2\2\u020c\u020a\3\2\2\2\u020c\u020d\3\2\2\2\u020d\u020f\3\2"+
+		"\2\2\u020e\u020c\3\2\2\2\u020f\u0210\7\13\2\2\u0210\u0212\7h\2\2\u0211"+
+		"\u0213\5N(\2\u0212\u0211\3\2\2\2\u0212\u0213\3\2\2\2\u0213\u0215\3\2\2"+
+		"\2\u0214\u0216\5R*\2\u0215\u0214\3\2\2\2\u0215\u0216\3\2\2\2\u0216\u0218"+
+		"\3\2\2\2\u0217\u0219\5T+\2\u0218\u0217\3\2\2\2\u0218\u0219\3\2\2\2\u0219"+
+		"\u021a\3\2\2\2\u021a\u021b\5X-\2\u021bK\3\2\2\2\u021c\u0225\5\u00d4k\2"+
+		"\u021d\u0225\7%\2\2\u021e\u0225\7$\2\2\u021f\u0225\7#\2\2\u0220\u0225"+
+		"\7\3\2\2\u0221\u0225\7(\2\2\u0222\u0225\7\24\2\2\u0223\u0225\7)\2\2\u0224"+
+		"\u021c\3\2\2\2\u0224\u021d\3\2\2\2\u0224\u021e\3\2\2\2\u0224\u021f\3\2"+
+		"\2\2\u0224\u0220\3\2\2\2\u0224\u0221\3\2\2\2\u0224\u0222\3\2\2\2\u0224"+
+		"\u0223\3\2\2\2\u0225M\3\2\2\2\u0226\u0227\7F\2\2\u0227\u0228\5P)\2\u0228"+
+		"\u0229\7E\2\2\u0229O\3\2\2\2\u022a\u022f\5 \21\2\u022b\u022c\7B\2\2\u022c"+
+		"\u022e\5 \21\2\u022d\u022b\3\2\2\2\u022e\u0231\3\2\2\2\u022f\u022d\3\2"+
+		"\2\2\u022f\u0230\3\2\2\2\u0230Q\3\2\2\2\u0231\u022f\3\2\2\2\u0232\u0233"+
+		"\7\23\2\2\u0233\u0234\5\16\b\2\u0234S\3\2\2\2\u0235\u0236\7\32\2\2\u0236"+
+		"\u0237\5V,\2\u0237U\3\2\2\2\u0238\u023d\5\24\13\2\u0239\u023a\7B\2\2\u023a"+
+		"\u023c\5\24\13\2\u023b\u0239\3\2\2\2\u023c\u023f\3\2\2\2\u023d\u023b\3"+
+		"\2\2\2\u023d\u023e\3\2\2\2\u023eW\3\2\2\2\u023f\u023d\3\2\2\2\u0240\u0244"+
+		"\7=\2\2\u0241\u0243\5Z.\2\u0242\u0241\3\2\2\2\u0243\u0246\3\2\2\2\u0244"+
 		"\u0242\3\2\2\2\u0244\u0245\3\2\2\2\u0245\u0247\3\2\2\2\u0246\u0244\3\2"+
 		"\2\2\u0247\u0248\7>\2\2\u0248Y\3\2\2\2\u0249\u024e\5\\/\2\u024a\u024e"+
 		"\5\u009cO\2\u024b\u024e\5\u009eP\2\u024c\u024e\5\u00a0Q\2\u024d\u0249"+
@@ -8594,63 +8545,62 @@ private boolean packageOrTypeName_sempred(PackageOrTypeNameContext _localctx, in
 		"\u03e3\3\2\2\2\u03e7\u03e4\3\2\2\2\u03e7\u03e5\3\2\2\2\u03e7\u03e6\3\2"+
 		"\2\2\u03e8\u00c7\3\2\2\2\u03e9\u03eb\5\u00caf\2\u03ea\u03e9\3\2\2\2\u03eb"+
 		"\u03ee\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03ed\3\2\2\2\u03ed\u03ef\3\2"+
-		"\2\2\u03ee\u03ec\3\2\2\2\u03ef\u03f1\5j\66\2\u03f0\u03f2\13\2\2\2\u03f1"+
-		"\u03f0\3\2\2\2\u03f2\u03f3\3\2\2\2\u03f3\u03f4\3\2\2\2\u03f3\u03f1\3\2"+
-		"\2\2\u03f4\u03f5\3\2\2\2\u03f5\u03f6\7A\2\2\u03f6\u00c9\3\2\2\2\u03f7"+
-		"\u03fc\5\u00d4k\2\u03f8\u03fc\7%\2\2\u03f9\u03fc\7(\2\2\u03fa\u03fc\7"+
-		"\24\2\2\u03fb\u03f7\3\2\2\2\u03fb\u03f8\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fb"+
-		"\u03fa\3\2\2\2\u03fc\u00cb\3\2\2\2\u03fd\u03ff\5\u00ceh\2\u03fe\u03fd"+
-		"\3\2\2\2\u03ff\u0402\3\2\2\2\u0400\u03fe\3\2\2\2\u0400\u0401\3\2\2\2\u0401"+
-		"\u0403\3\2\2\2\u0402\u0400\3\2\2\2\u0403\u0404\5\u0082B\2\u0404\u0405"+
-		"\5\u009aN\2\u0405\u00cd\3\2\2\2\u0406\u040d\5\u00d4k\2\u0407\u040d\7%"+
-		"\2\2\u0408\u040d\7\3\2\2\u0409\u040d\7\16\2\2\u040a\u040d\7(\2\2\u040b"+
-		"\u040d\7)\2\2\u040c\u0406\3\2\2\2\u040c\u0407\3\2\2\2\u040c\u0408\3\2"+
-		"\2\2\u040c\u0409\3\2\2\2\u040c\u040a\3\2\2\2\u040c\u040b\3\2\2\2\u040d"+
-		"\u00cf\3\2\2\2\u040e\u0410\5\u00c0a\2\u040f\u040e\3\2\2\2\u0410\u0413"+
-		"\3\2\2\2\u0411\u040f\3\2\2\2\u0411\u0412\3\2\2\2\u0412\u0414\3\2\2\2\u0413"+
-		"\u0411\3\2\2\2\u0414\u0415\7i\2\2\u0415\u0416\7\36\2\2\u0416\u0417\7h"+
-		"\2\2\u0417\u0418\5\u00d2j\2\u0418\u00d1\3\2\2\2\u0419\u041b\7=\2\2\u041a"+
-		"\u041c\13\2\2\2\u041b\u041a\3\2\2\2\u041c\u041d\3\2\2\2\u041d\u041e\3"+
-		"\2\2\2\u041d\u041b\3\2\2\2\u041e\u041f\3\2\2\2\u041f\u0420\7>\2\2\u0420"+
-		"\u00d3\3\2\2\2\u0421\u0425\5\u00d6l\2\u0422\u0425\5\u00e2r\2\u0423\u0425"+
-		"\5\u00e4s\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424\u0423\3\2\2"+
-		"\2\u0425\u00d5\3\2\2\2\u0426\u0427\7i\2\2\u0427\u0428\5\62\32\2\u0428"+
-		"\u042a\7;\2\2\u0429\u042b\5\u00d8m\2\u042a\u0429\3\2\2\2\u042a\u042b\3"+
-		"\2\2\2\u042b\u042c\3\2\2\2\u042c\u042d\7<\2\2\u042d\u00d7\3\2\2\2\u042e"+
-		"\u0433\5\u00dan\2\u042f\u0430\7B\2\2\u0430\u0432\5\u00dan\2\u0431\u042f"+
-		"\3\2\2\2\u0432\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434"+
-		"\u00d9\3\2\2\2\u0435\u0433\3\2\2\2\u0436\u0437\7h\2\2\u0437\u0438\7D\2"+
-		"\2\u0438\u0439\5\u00dco\2\u0439\u00db\3\2\2\2\u043a\u043e\5\u00ba^\2\u043b"+
-		"\u043e\5\u00dep\2\u043c\u043e\5\u00d4k\2\u043d\u043a\3\2\2\2\u043d\u043b"+
-		"\3\2\2\2\u043d\u043c\3\2\2\2\u043e\u00dd\3\2\2\2\u043f\u0441\7=\2\2\u0440"+
-		"\u0442\5\u00e0q\2\u0441\u0440\3\2\2\2\u0441\u0442\3\2\2\2\u0442\u0444"+
-		"\3\2\2\2\u0443\u0445\7B\2\2\u0444\u0443\3\2\2\2\u0444\u0445\3\2\2\2\u0445"+
-		"\u0446\3\2\2\2\u0446\u0447\7>\2\2\u0447\u00df\3\2\2\2\u0448\u044d\5\u00dc"+
-		"o\2\u0449\u044a\7B\2\2\u044a\u044c\5\u00dco\2\u044b\u0449\3\2\2\2\u044c"+
-		"\u044f\3\2\2\2\u044d\u044b\3\2\2\2\u044d\u044e\3\2\2\2\u044e\u00e1\3\2"+
-		"\2\2\u044f\u044d\3\2\2\2\u0450\u0451\7i\2\2\u0451\u0452\5\62\32\2\u0452"+
-		"\u00e3\3\2\2\2\u0453\u0454\7i\2\2\u0454\u0455\5\62\32\2\u0455\u0456\7"+
-		";\2\2\u0456\u0457\5\u00dco\2\u0457\u0458\7<\2\2\u0458\u00e5\3\2\2\2\u0459"+
-		"\u045b\7=\2\2\u045a\u045c\5\u00e8u\2\u045b\u045a\3\2\2\2\u045b\u045c\3"+
-		"\2\2\2\u045c\u045e\3\2\2\2\u045d\u045f\7B\2\2\u045e\u045d\3\2\2\2\u045e"+
-		"\u045f\3\2\2\2\u045f\u0460\3\2\2\2\u0460\u0461\7>\2\2\u0461\u00e7\3\2"+
-		"\2\2\u0462\u0467\5h\65\2\u0463\u0464\7B\2\2\u0464\u0466\5h\65\2\u0465"+
-		"\u0463\3\2\2\2\u0466\u0469\3\2\2\2\u0467\u0465\3\2\2\2\u0467\u0468\3\2"+
-		"\2\2\u0468\u00e9\3\2\2\2\u0469\u0467\3\2\2\2\u046a\u046b\7=\2\2\u046b"+
-		"\u046c\5\u00ecw\2\u046c\u046d\7>\2\2\u046d\u00eb\3\2\2\2\u046e\u0470\13"+
-		"\2\2\2\u046f\u046e\3\2\2\2\u0470\u0473\3\2\2\2\u0471\u0472\3\2\2\2\u0471"+
-		"\u046f\3\2\2\2\u0472\u00ed\3\2\2\2\u0473\u0471\3\2\2\2\u0088\u00f1\u00f8"+
-		"\u00fc\u0100\u0109\u010d\u0111\u0113\u0119\u011e\u0125\u012a\u012c\u0132"+
-		"\u0137\u013c\u0141\u014c\u015a\u015f\u0167\u016e\u0174\u0179\u0184\u0187"+
-		"\u0195\u019a\u019f\u01a4\u01aa\u01b1\u01bb\u01bf\u01c4\u01ca\u01d2\u01db"+
-		"\u01e6\u0203\u0207\u020c\u0212\u0215\u0218\u0224\u022f\u023d\u0244\u024d"+
-		"\u0254\u0259\u0268\u026f\u0275\u0279\u027d\u0281\u0285\u028a\u028e\u0292"+
-		"\u0294\u029b\u02a0\u02a4\u02b5\u02ba\u02ca\u02cf\u02d5\u02db\u02dd\u02e1"+
-		"\u02e6\u02ea\u02f1\u02f8\u0300\u0303\u0308\u0310\u0315\u031c\u0323\u0328"+
-		"\u032e\u033a\u033f\u0343\u034d\u0352\u035a\u035d\u0362\u036f\u0375\u037b"+
-		"\u037e\u0381\u038a\u0390\u0396\u0399\u039c\u03a4\u03ac\u03b2\u03b7\u03bb"+
-		"\u03c0\u03c6\u03c9\u03d4\u03dd\u03e7\u03ec\u03f3\u03fb\u0400\u040c\u0411"+
-		"\u041d\u0424\u042a\u0433\u043d\u0441\u0444\u044d\u045b\u045e\u0467\u0471";
+		"\2\2\u03ee\u03ec\3\2\2\2\u03ef\u03f0\5j\66\2\u03f0\u03f1\5b\62\2\u03f1"+
+		"\u03f2\7A\2\2\u03f2\u00c9\3\2\2\2\u03f3\u03f8\5\u00d4k\2\u03f4\u03f8\7"+
+		"%\2\2\u03f5\u03f8\7(\2\2\u03f6\u03f8\7\24\2\2\u03f7\u03f3\3\2\2\2\u03f7"+
+		"\u03f4\3\2\2\2\u03f7\u03f5\3\2\2\2\u03f7\u03f6\3\2\2\2\u03f8\u00cb\3\2"+
+		"\2\2\u03f9\u03fb\5\u00ceh\2\u03fa\u03f9\3\2\2\2\u03fb\u03fe\3\2\2\2\u03fc"+
+		"\u03fa\3\2\2\2\u03fc\u03fd\3\2\2\2\u03fd\u03ff\3\2\2\2\u03fe\u03fc\3\2"+
+		"\2\2\u03ff\u0400\5\u0082B\2\u0400\u0401\5\u009aN\2\u0401\u00cd\3\2\2\2"+
+		"\u0402\u0409\5\u00d4k\2\u0403\u0409\7%\2\2\u0404\u0409\7\3\2\2\u0405\u0409"+
+		"\7\16\2\2\u0406\u0409\7(\2\2\u0407\u0409\7)\2\2\u0408\u0402\3\2\2\2\u0408"+
+		"\u0403\3\2\2\2\u0408\u0404\3\2\2\2\u0408\u0405\3\2\2\2\u0408\u0406\3\2"+
+		"\2\2\u0408\u0407\3\2\2\2\u0409\u00cf\3\2\2\2\u040a\u040c\5\u00c0a\2\u040b"+
+		"\u040a\3\2\2\2\u040c\u040f\3\2\2\2\u040d\u040b\3\2\2\2\u040d\u040e\3\2"+
+		"\2\2\u040e\u0410\3\2\2\2\u040f\u040d\3\2\2\2\u0410\u0411\7i\2\2\u0411"+
+		"\u0412\7\36\2\2\u0412\u0413\7h\2\2\u0413\u0414\5\u00d2j\2\u0414\u00d1"+
+		"\3\2\2\2\u0415\u0419\7=\2\2\u0416\u0418\13\2\2\2\u0417\u0416\3\2\2\2\u0418"+
+		"\u041b\3\2\2\2\u0419\u041a\3\2\2\2\u0419\u0417\3\2\2\2\u041a\u041c\3\2"+
+		"\2\2\u041b\u0419\3\2\2\2\u041c\u041d\7>\2\2\u041d\u00d3\3\2\2\2\u041e"+
+		"\u0422\5\u00d6l\2\u041f\u0422\5\u00e2r\2\u0420\u0422\5\u00e4s\2\u0421"+
+		"\u041e\3\2\2\2\u0421\u041f\3\2\2\2\u0421\u0420\3\2\2\2\u0422\u00d5\3\2"+
+		"\2\2\u0423\u0424\7i\2\2\u0424\u0425\5\62\32\2\u0425\u0427\7;\2\2\u0426"+
+		"\u0428\5\u00d8m\2\u0427\u0426\3\2\2\2\u0427\u0428\3\2\2\2\u0428\u0429"+
+		"\3\2\2\2\u0429\u042a\7<\2\2\u042a\u00d7\3\2\2\2\u042b\u0430\5\u00dan\2"+
+		"\u042c\u042d\7B\2\2\u042d\u042f\5\u00dan\2\u042e\u042c\3\2\2\2\u042f\u0432"+
+		"\3\2\2\2\u0430\u042e\3\2\2\2\u0430\u0431\3\2\2\2\u0431\u00d9\3\2\2\2\u0432"+
+		"\u0430\3\2\2\2\u0433\u0434\7h\2\2\u0434\u0435\7D\2\2\u0435\u0436\5\u00dc"+
+		"o\2\u0436\u00db\3\2\2\2\u0437\u043b\5\u00ba^\2\u0438\u043b\5\u00dep\2"+
+		"\u0439\u043b\5\u00d4k\2\u043a\u0437\3\2\2\2\u043a\u0438\3\2\2\2\u043a"+
+		"\u0439\3\2\2\2\u043b\u00dd\3\2\2\2\u043c\u043e\7=\2\2\u043d\u043f\5\u00e0"+
+		"q\2\u043e\u043d\3\2\2\2\u043e\u043f\3\2\2\2\u043f\u0441\3\2\2\2\u0440"+
+		"\u0442\7B\2\2\u0441\u0440\3\2\2\2\u0441\u0442\3\2\2\2\u0442\u0443\3\2"+
+		"\2\2\u0443\u0444\7>\2\2\u0444\u00df\3\2\2\2\u0445\u044a\5\u00dco\2\u0446"+
+		"\u0447\7B\2\2\u0447\u0449\5\u00dco\2\u0448\u0446\3\2\2\2\u0449\u044c\3"+
+		"\2\2\2\u044a\u0448\3\2\2\2\u044a\u044b\3\2\2\2\u044b\u00e1\3\2\2\2\u044c"+
+		"\u044a\3\2\2\2\u044d\u044e\7i\2\2\u044e\u044f\5\62\32\2\u044f\u00e3\3"+
+		"\2\2\2\u0450\u0451\7i\2\2\u0451\u0452\5\62\32\2\u0452\u0453\7;\2\2\u0453"+
+		"\u0454\5\u00dco\2\u0454\u0455\7<\2\2\u0455\u00e5\3\2\2\2\u0456\u0458\7"+
+		"=\2\2\u0457\u0459\5\u00e8u\2\u0458\u0457\3\2\2\2\u0458\u0459\3\2\2\2\u0459"+
+		"\u045b\3\2\2\2\u045a\u045c\7B\2\2\u045b\u045a\3\2\2\2\u045b\u045c\3\2"+
+		"\2\2\u045c\u045d\3\2\2\2\u045d\u045e\7>\2\2\u045e\u00e7\3\2\2\2\u045f"+
+		"\u0464\5h\65\2\u0460\u0461\7B\2\2\u0461\u0463\5h\65\2\u0462\u0460\3\2"+
+		"\2\2\u0463\u0466\3\2\2\2\u0464\u0462\3\2\2\2\u0464\u0465\3\2\2\2\u0465"+
+		"\u00e9\3\2\2\2\u0466\u0464\3\2\2\2\u0467\u0468\7=\2\2\u0468\u0469\5\u00ec"+
+		"w\2\u0469\u046a\7>\2\2\u046a\u00eb\3\2\2\2\u046b\u046d\13\2\2\2\u046c"+
+		"\u046b\3\2\2\2\u046d\u0470\3\2\2\2\u046e\u046f\3\2\2\2\u046e\u046c\3\2"+
+		"\2\2\u046f\u00ed\3\2\2\2\u0470\u046e\3\2\2\2\u0087\u00f1\u00f8\u00fc\u0100"+
+		"\u0109\u010d\u0111\u0113\u0119\u011e\u0125\u012a\u012c\u0132\u0137\u013c"+
+		"\u0141\u014c\u015a\u015f\u0167\u016e\u0174\u0179\u0184\u0187\u0195\u019a"+
+		"\u019f\u01a4\u01aa\u01b1\u01bb\u01bf\u01c4\u01ca\u01d2\u01db\u01e6\u0203"+
+		"\u0207\u020c\u0212\u0215\u0218\u0224\u022f\u023d\u0244\u024d\u0254\u0259"+
+		"\u0268\u026f\u0275\u0279\u027d\u0281\u0285\u028a\u028e\u0292\u0294\u029b"+
+		"\u02a0\u02a4\u02b5\u02ba\u02ca\u02cf\u02d5\u02db\u02dd\u02e1\u02e6\u02ea"+
+		"\u02f1\u02f8\u0300\u0303\u0308\u0310\u0315\u031c\u0323\u0328\u032e\u033a"+
+		"\u033f\u0343\u034d\u0352\u035a\u035d\u0362\u036f\u0375\u037b\u037e\u0381"+
+		"\u038a\u0390\u0396\u0399\u039c\u03a4\u03ac\u03b2\u03b7\u03bb\u03c0\u03c6"+
+		"\u03c9\u03d4\u03dd\u03e7\u03ec\u03f7\u03fc\u0408\u040d\u0419\u0421\u0427"+
+		"\u0430\u043a\u043e\u0441\u044a\u0458\u045b\u0464\u046e";
 	public static final ATN _ATN =
 		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
 	static {
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaVisitor.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaVisitor.java
index 0010f2d..13babda 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaVisitor.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaVisitor.java
@@ -515,12 +515,11 @@ public interface DroppingJavaVisitor<T> extends ParseTreeVisitor<T> {
 	 */
 	T visitConstructorBody(DroppingJavaParser.ConstructorBodyContext ctx);
 	/**
-	 * Visit a parse tree produced by the {@code EnumName}
-	 * labeled alternative in {@link DroppingJavaParser#enumDeclaration}.
+	 * Visit a parse tree produced by {@link DroppingJavaParser#enumDeclaration}.
 	 * @param ctx the parse tree
 	 * @return the visitor result
 	 */
-	T visitEnumName(DroppingJavaParser.EnumNameContext ctx);
+	T visitEnumDeclaration(DroppingJavaParser.EnumDeclarationContext ctx);
 	/**
 	 * Visit a parse tree produced by {@link DroppingJavaParser#enumBody}.
 	 * @param ctx the parse tree
@@ -576,12 +575,11 @@ public interface DroppingJavaVisitor<T> extends ParseTreeVisitor<T> {
 	 */
 	T visitInterfaceDeclaration(DroppingJavaParser.InterfaceDeclarationContext ctx);
 	/**
-	 * Visit a parse tree produced by the {@code IfaceName}
-	 * labeled alternative in {@link DroppingJavaParser#normalInterfaceDeclaration}.
+	 * Visit a parse tree produced by {@link DroppingJavaParser#normalInterfaceDeclaration}.
 	 * @param ctx the parse tree
 	 * @return the visitor result
 	 */
-	T visitIfaceName(DroppingJavaParser.IfaceNameContext ctx);
+	T visitNormalInterfaceDeclaration(DroppingJavaParser.NormalInterfaceDeclarationContext ctx);
 	/**
 	 * Visit a parse tree produced by {@link DroppingJavaParser#interfaceModifier}.
 	 * @param ctx the parse tree
@@ -631,12 +629,11 @@ public interface DroppingJavaVisitor<T> extends ParseTreeVisitor<T> {
 	 */
 	T visitInterfaceMethodModifier(DroppingJavaParser.InterfaceMethodModifierContext ctx);
 	/**
-	 * Visit a parse tree produced by the {@code AnnoName}
-	 * labeled alternative in {@link DroppingJavaParser#annotationTypeDeclaration}.
+	 * Visit a parse tree produced by {@link DroppingJavaParser#annotationTypeDeclaration}.
 	 * @param ctx the parse tree
 	 * @return the visitor result
 	 */
-	T visitAnnoName(DroppingJavaParser.AnnoNameContext ctx);
+	T visitAnnotationTypeDeclaration(DroppingJavaParser.AnnotationTypeDeclarationContext ctx);
 	/**
 	 * Visit a parse tree produced by {@link DroppingJavaParser#annotationTypeBody}.
 	 * @param ctx the parse tree
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java
index 9a01fb5..1fcb60d 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java
@@ -76,6 +76,9 @@ public void methodHeadersAreRecognizedFully() throws Exception {
             "\tTargetMethod{name='method8', cutpoint=null, resultType=Set, formalParams=(EventObject eo), text=\n" +
             "\t\treturn Collections . emptySet ( ) ;\n" +
             "\t}\n" +
+            "\tTargetMethod{name='method9', cutpoint=null, resultType=T, formalParams=(T source, boolean flag), text=\n" +
+            "\t\treturn ( T ) new BufferedInputStream ( source ) ;\n" +
+            "\t}\n" +
             "}\n" +
             "VariousMethodHeaders.InnerClass -> {\n" +
             "\tTargetMethod{name='InnerClass', cutpoint=null, resultType=null, formalParams=(Deque arg), text=(empty)}\n" +
@@ -103,6 +106,102 @@ public void methodBodiesAreRecognizedFully() throws Exception {
     assertEquals(expected, actual);
   }
 
+  @Test
+  public void enumTypesAreRecognizedFully() throws Exception {
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/RootEnumeration.java";
+    TargetsMap targetsMap = loadDroplet(dropletPath);
+    String expected = "RootEnumeration -> {\n" +
+            "\tTargetMethod{name='RootEnumeration', cutpoint=null, resultType=null, formalParams=(), text=\n" +
+            "\t\tString nothing = \"I'm the most enumerated constructor ever!\" ;\n" +
+            "\t}\n" +
+            "\tTargetMethod{name='getByName', cutpoint=null, resultType=RootEnumeration, formalParams=(String name), text=\n" +
+            "\t\tfor ( RootEnumeration rootEnum : values ( ) ) { if ( rootEnum . toString ( ) . equals ( name ) ) { return rootEnum ; } } throw new IllegalArgumentException ( \"Not found: \" + name ) ;\n" +
+            "\t}\n" +
+            "}\n" +
+            "RootEnumeration.InnerEnum -> {\n" +
+            "\tTargetMethod{name='isTheSame', cutpoint=null, resultType=boolean, formalParams=(Enum e), text=\n" +
+            "\t\treturn INNER_ENUM . toString ( ) . equals ( e . toString ( ) ) ;\n" +
+            "\t}\n" +
+            "}\n";
+    String actual = targetsMap.toString();
+    System.out.println(actual);
+    assertEquals(expected, actual);
+  }
+
+  @Test
+  public void interfaceTypesAreRecognizedFully() throws Exception {
+    String dropletPath = "src/test/resources/RootInterface.java";
+    TargetsMap targetsMap = loadDroplet(dropletPath);
+    String expected = "RootInterface -> {\n" +
+            "\tTargetMethod{name='method1', cutpoint=null, resultType=void, formalParams=(), text=(empty)}\n" +
+            "\tTargetMethod{name='method2', cutpoint=null, resultType=boolean, formalParams=(int two), text=(empty)}\n" +
+            "\tTargetMethod{name='method3', cutpoint=null, resultType=RootInterface, formalParams=(Set longs), text=(empty)}\n" +
+            "\tTargetMethod{name='method5', cutpoint=null, resultType=double, formalParams=(Float param1), text=\n" +
+            "\t\treturn Math . random ( ) ;\n" +
+            "\t}\n" +
+            "\tTargetMethod{name='newObservable', cutpoint=null, resultType=Observable, formalParams=(List lof), text=\n" +
+            "\t\treturn new Observable ( ) ;\n" +
+            "\t}\n" +
+            "}\n" +
+            "RootInterface.InnerIface -> {\n" +
+            "\tTargetMethod{name='method1', cutpoint=null, resultType=InputStream, formalParams=(), text=\n" +
+            "\t\treturn new FileInputStream ( \"\" ) ;\n" +
+            "\t}\n" +
+            "}\n" +
+            "RootInterface.InnerIface.InnerInnerIface -> {\n" +
+            "\tTargetMethod{name='method1', cutpoint=null, resultType=OutputStream, formalParams=(), text=\n" +
+            "\t\treturn new FileOutputStream ( \"\" ) ;\n" +
+            "\t}\n" +
+            "}\n";
+    String actual = targetsMap.toString();
+    System.out.println(actual);
+    assertEquals(expected, actual);
+  }
+
+  @Test
+  public void typesCombinationsAreRecognizedFully() throws Exception {
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/TypesCombination.java";
+    TargetsMap targetsMap = loadDroplet(dropletPath);
+
+    String actual = targetsMap.toString();
+    System.out.println(actual);
+    String expected = "SiblingClass -> {\n" +
+            "\tTargetMethod{name='method', cutpoint=null, resultType=double, formalParams=(), text=\n" +
+            "\t\treturn Math . random ( ) ;\n" +
+            "\t}\n" +
+            "}\n" +
+            "SiblingEnum -> {\n" +
+            "\tTargetMethod{name='SiblingEnum', cutpoint=null, resultType=null, formalParams=(), text=(empty)}\n" +
+            "\tTargetMethod{name='getMe', cutpoint=null, resultType=SiblingEnum, formalParams=(), text=\n" +
+            "\t\treturn this ;\n" +
+            "\t}\n" +
+            "}\n" +
+            "SiblingEnum.InnerInterface -> {\n" +
+            "\tTargetMethod{name='getThatEnum', cutpoint=null, resultType=TypesCombination.InnerInterface.InnerInnerClass.InnerInnerInnerEnum, formalParams=(), text=(empty)}\n" +
+            "}\n" +
+            "SiblingInterface -> {\n" +
+            "\tTargetMethod{name='method', cutpoint=null, resultType=Vector, formalParams=(Vector arg), text=(empty)}\n" +
+            "}\n" +
+            "SiblingInterface.InnerEnum -> {\n" +
+            "\tTargetMethod{name='InnerEnum', cutpoint=null, resultType=null, formalParams=(), text=(empty)}\n" +
+            "}\n" +
+            "TypesCombination -> {\n" +
+            "\tTargetMethod{name='method1', cutpoint=null, resultType=void, formalParams=(), text=\n" +
+            "\t\tSystem . console ( ) ;\n" +
+            "\t}\n" +
+            "}\n" +
+            "TypesCombination.InnerInterface -> {\n" +
+            "\tTargetMethod{name='innerMethod', cutpoint=null, resultType=void, formalParams=(), text=(empty)}\n" +
+            "}\n" +
+            "TypesCombination.InnerInterface.InnerInnerClass -> {\n" +
+            "\tTargetMethod{name='innerInnerMethod', cutpoint=null, resultType=void, formalParams=(), text=(empty)}\n" +
+            "}\n" +
+            "TypesCombination.InnerInterface.InnerInnerClass.InnerInnerInnerEnum -> {\n" +
+            "\tTargetMethod{name='doSomething', cutpoint=null, resultType=void, formalParams=(), text=(empty)}\n" +
+            "}\n";
+    assertEquals(expected, actual);
+  }
+
   private TargetsMap loadDroplet(String dropletPath) throws IOException {
     ANTLRFileStream fileStream = new ANTLRFileStream(dropletPath);
     DroppingJavaLexer lexer = new DroppingJavaLexer(fileStream);
diff --git a/src/test/resources/FaultyTypesCombination.java b/src/test/resources/FaultyTypesCombination.java
new file mode 100644
index 0000000..1dfc8dd
--- /dev/null
+++ b/src/test/resources/FaultyTypesCombination.java
@@ -0,0 +1,83 @@
+package ru.ftc.upc.testing.dropper.lang.droplets;
+
+import java.util.Vector;
+
+/**
+ * This combination makes ANTLR 4.5.1 build an incorrect parse tree on DroppingJava grammar.
+ * When accepting SuppressWarnings annotation just before SiblingInterface_ interface, the parser includes the whole
+ * body of the interface into the value of annotation's parameter (instead of just "unused" value). The parser stops
+ * "consuming" just when it faces the end of the next SuppressWarnings annotation. The reason of this behavior is
+ * still unknown but the observations were done that locating the interface after the following
+ * SiblingEnumeration_ enumeration makes the error disappear. Another way is to transform the interface into a class.
+ * For the time being this error is not considered critical but should be investigated in order to prevent such
+ * behavior in other circumstances.
+ * Possible solution may be found in "The Definitive ANTLR 4 Reference", §15.6.
+ *
+ * @author Toparvion
+ */
+@SuppressWarnings("unused")
+public class FaultyTypesCombination {
+  void method1() {
+    System.console();
+  }
+
+  interface InnerInterface {
+    void innerMethod();
+
+    class InnerInnerClass {
+      void innerInnerMethod() { }
+
+      enum InnerInnerInnerEnum {
+        ;
+        static void doSomething() { }
+      }
+
+    }
+
+    @interface InnerAnnotation {
+      int method() default 2;
+    }
+
+  }
+}
+
+@SuppressWarnings("unused")
+class SiblingClass_ {
+  public double method() {
+    return Math.random();
+  }
+}
+
+@SuppressWarnings("unused")
+interface SiblingInterface_ {
+  Vector<Object> method(Vector<String> arg);
+
+  enum InnerEnum {
+    ;
+
+    InnerEnum() { }
+  }
+}
+
+@SuppressWarnings("unused")
+enum SiblingEnum_ {
+  ;
+
+  SiblingEnum() {
+  }
+
+  SiblingEnum getMe() {
+    return this;
+  }
+
+  interface InnerInterface {
+    TypesCombination.InnerInterface.InnerInnerClass.InnerInnerInnerEnum getThatEnum();
+  }
+
+  @interface InnerAnnotation {
+
+  }
+
+}
+
+
diff --git a/src/test/resources/RootInterface.java b/src/test/resources/RootInterface.java
new file mode 100644
index 0000000..edc79b0
--- /dev/null
+++ b/src/test/resources/RootInterface.java
@@ -0,0 +1,44 @@
+package ru.ftc.upc.testing.dropper.lang;
+
+import java.io.*;
+import java.util.List;
+import java.util.Observable;
+import java.util.Set;
+
+/**
+ * This class is isolated in resources test directory because it uses Java 8 language features (default and static
+ * methods) that are not supported in the rest project (as it designed to be compatible with JDK 1.6+ applications).
+ * @author Toparvion
+ */
+@SuppressWarnings("unused")
+public interface RootInterface {
+
+  void method1();
+
+  boolean method2(int two);
+
+  RootInterface method3(Set<Long> longs);
+
+  default double method5(Float param1) {
+    return Math.random();
+  }
+
+  static Observable newObservable(List<Object> lof) {
+    return new Observable();
+  }
+
+  interface InnerIface {
+
+    static InputStream method1() {
+      return new FileInputStream("");
+    }
+
+    interface InnerInnerIface {
+
+      default OutputStream method1() {
+        return new FileOutputStream("");
+      }
+    }
+  }
+
+}

From 4650f4425029f9f98281162881afa8e2665f0faf Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Wed, 1 Jun 2016 16:27:59 +0600
Subject: [PATCH 06/22] UPCSEC-0000 Implemented recognition of single type
 imports and package declaration

---
 ...reeListener.java => DropletAssembler.java} |  72 +++++++++--
 .../dropper/lang/DropletFormatException.java  |  10 ++
 ...nerTest.java => DropletAssemblerTest.java} | 119 +++++++++++-------
 src/test/resources/FaultyImports.java         |  13 ++
 src/test/resources/Imports.java               |  12 ++
 src/test/resources/RootInterface.java         |   5 +-
 6 files changed, 179 insertions(+), 52 deletions(-)
 rename src/main/java/ru/ftc/upc/testing/dropper/lang/{DropperTreeListener.java => DropletAssembler.java} (65%)
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/DropletFormatException.java
 rename src/test/java/ru/ftc/upc/testing/dropper/lang/{DropperTreeListenerTest.java => DropletAssemblerTest.java} (72%)
 create mode 100644 src/test/resources/FaultyImports.java
 create mode 100644 src/test/resources/Imports.java

diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
similarity index 65%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java
rename to src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
index 606da61..6912e16 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListener.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
@@ -1,23 +1,50 @@
 package ru.ftc.upc.testing.dropper.lang;
 
 import org.antlr.v4.runtime.RuleContext;
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.tree.TerminalNode;
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaBaseListener;
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaVisitor;
 import ru.ftc.upc.testing.dropper.model.Argument;
 import ru.ftc.upc.testing.dropper.model.TargetMethod;
 
-import java.util.Deque;
-import java.util.Iterator;
-import java.util.LinkedList;
+import java.util.*;
 
 /**
  * @author Toparvion
  */
-public class DropperTreeListener extends DroppingJavaBaseListener {
+class DropletAssembler extends DroppingJavaBaseListener {
 
-  private Deque<String> classNameStack = new LinkedList<String>();
-  private TargetsMap targetsMap = new TargetsMap();
+  /**
+   * Mapping between simple type names (e.g. "Droplet") and their FQ prefixes (e.g. "ru.ftc.upc.testing.dropper").
+   * The mapping is built from the import statements at the header of compilation unit and does not include any type
+   * import on demand.
+   */
+  private final Map<String, String> importsMap = new LinkedHashMap<String, String>(10);
+  /**
+   * Mapping between all target classes and lists of their methods. These methods are targets for byte
+   * code instrumenting.
+   */
+  private final TargetsMap targetsMap = new TargetsMap();
+
+  /**
+   * Package prefix for the target type(s), e.g. "tech.toparvion.dropper.lang.droplets."
+   */
+  private String packageDeclaration = "";
+  /**
+   * Internal data structure aimed to support depth tracking during parse tree traversing.
+   */
+  private final Deque<String> classNameStack = new LinkedList<String>();
+
+  @Override
+  public void enterPackageDeclaration(DroppingJavaParser.PackageDeclarationContext ctx) {
+    StringBuilder sb = new StringBuilder();
+    for (TerminalNode idNode : ctx.Identifier()) {
+      sb.append(idNode.getText()).append(".");
+    }
+    this.packageDeclaration = sb.toString();
+  }
 
   @Override
   public void enterNormalClassDeclaration(DroppingJavaParser.NormalClassDeclarationContext ctx) {
@@ -116,16 +143,39 @@ private void storeMethodParams(TargetMethod method, DroppingJavaParser.FormalPar
     }
   }
 
+  @Override
+  public void enterSingleTypeImportDeclaration(DroppingJavaParser.SingleTypeImportDeclarationContext ctx) {
+    DroppingJavaParser.TypeNameContext typeName = ctx.typeName();
+    if (typeName.packageOrTypeName() == null) {
+      // in this case there is no profit in mapping a type to its import prefix so that we just ignore it
+      return;
+    }
+    importsMap.put(typeName.Identifier().getText(), typeName.packageOrTypeName().getText());
+  }
+
+  /**
+   * Type imports on demand are not supported in this version because they introduce quite complicated ambiguity. In
+   * order not to mute their existence we prefer to explicitly inform the user about them with the help of exception.
+   */
+  @Override
+  public void enterTypeImportOnDemandDeclaration(DroppingJavaParser.TypeImportOnDemandDeclarationContext ctx) {
+    Token offendingToken = ctx.getToken(DroppingJavaParser.IMPORT, 0).getSymbol();
+    String offendingImportString = String.format("import %s.*;", ctx.packageOrTypeName().getText());
+    throw new DropletFormatException(String.format("Line %d:%d. Type imports on demand are not supported: '%s'. " +
+            "Please replace it with a set of single type imports.",
+            offendingToken.getLine(), offendingToken.getCharPositionInLine(), offendingImportString));
+  }
+
   /**
    * @return a key for targets map (composed basing on current state of the stack)
    */
   private String composeCurrentKey() {
-    StringBuilder sb = new StringBuilder();
+    StringBuilder sb = new StringBuilder(packageDeclaration);
     boolean first = true;
     for (Iterator<String> iterator = classNameStack.descendingIterator(); iterator.hasNext(); ) {
       String className = iterator.next();
       if (!first) {
-        sb.append(".");
+        sb.append("$");
       } else {
         first = false;
       }
@@ -135,10 +185,14 @@ private String composeCurrentKey() {
     return sb.toString();
   }
 
-  public TargetsMap getTargetsMap() {
+  TargetsMap getTargetsMap() {
     return targetsMap;
   }
 
+  Map<String, String> getImportsMap() {
+    return importsMap;
+  }
+
   private String getPureTypeName(RuleContext typeCtx) {
     DroppingJavaVisitor<String> visitor = new PureTypeNameComposingVisitor();
     return visitor.visit(typeCtx);
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletFormatException.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletFormatException.java
new file mode 100644
index 0000000..55e6f73
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletFormatException.java
@@ -0,0 +1,10 @@
+package ru.ftc.upc.testing.dropper.lang;
+
+/**
+ * @author Toparvion
+ */
+public class DropletFormatException extends RuntimeException {
+  public DropletFormatException(String message) {
+    super(message);
+  }
+}
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
similarity index 72%
rename from src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java
rename to src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
index 1fcb60d..4f2f83f 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropperTreeListenerTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
@@ -10,19 +10,23 @@
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
 
 import java.io.IOException;
+import java.util.Map;
+import java.util.Set;
 
 import static org.junit.Assert.assertEquals;
 
 /**
  * @author Toparvion
  */
-public class DropperTreeListenerTest {
+public class DropletAssemblerTest {
 
   @Test
   public void nestedClassesAreRecognizedFully() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/MultiNestedClasses.java";
-    TargetsMap targetsMap = loadDroplet(dropletPath);
-    String expected = "MultiNestedClasses -> {\n" +
+    TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
+    String actual = targetsMap.toString();
+    System.out.println(actual);
+    String expected = "ru.ftc.upc.testing.dropper.lang.droplets.MultiNestedClasses -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=null, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 1 ;\n" +
             "\t}\n" +
@@ -33,7 +37,7 @@ public void nestedClassesAreRecognizedFully() throws Exception {
             "\t\treturn 7 ;\n" +
             "\t}\n" +
             "}\n" +
-            "MultiNestedClasses.InnerClass1 -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.droplets.MultiNestedClasses$InnerClass1 -> {\n" +
             "\tTargetMethod{name='method2', cutpoint=null, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 2 ;\n" +
             "\t}\n" +
@@ -41,26 +45,26 @@ public void nestedClassesAreRecognizedFully() throws Exception {
             "\t\treturn 3 ;\n" +
             "\t}\n" +
             "}\n" +
-            "MultiNestedClasses.InnerClass2 -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.droplets.MultiNestedClasses$InnerClass2 -> {\n" +
             "\tTargetMethod{name='method5', cutpoint=null, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 5 ;\n" +
             "\t}\n" +
             "}\n" +
-            "MultiNestedClasses.InnerClass2.InnerClass3 -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.droplets.MultiNestedClasses$InnerClass2$InnerClass3 -> {\n" +
             "\tTargetMethod{name='method6', cutpoint=null, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 6 ;\n" +
             "\t}\n" +
             "}\n";
-    String actual = targetsMap.toString();
-    System.out.println(actual);
     assertEquals(expected, actual);
   }
 
   @Test
   public void methodHeadersAreRecognizedFully() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/VariousMethodHeaders.java";
-    TargetsMap targetsMap = loadDroplet(dropletPath);
-    String expected = "VariousMethodHeaders -> {\n" +
+    TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
+    String actual = targetsMap.toString();
+    System.out.println(actual);
+    String expected = "ru.ftc.upc.testing.dropper.lang.droplets.VariousMethodHeaders -> {\n" +
             "\tTargetMethod{name='VariousMethodHeaders', cutpoint=null, resultType=null, formalParams=(), text=(empty)}\n" +
             "\tTargetMethod{name='VariousMethodHeaders', cutpoint=null, resultType=null, formalParams=(Stack param1), text=(empty)}\n" +
             "\tTargetMethod{name='VariousMethodHeaders', cutpoint=null, resultType=null, formalParams=(float arg), text=(empty)}\n" +
@@ -80,19 +84,19 @@ public void methodHeadersAreRecognizedFully() throws Exception {
             "\t\treturn ( T ) new BufferedInputStream ( source ) ;\n" +
             "\t}\n" +
             "}\n" +
-            "VariousMethodHeaders.InnerClass -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.droplets.VariousMethodHeaders$InnerClass -> {\n" +
             "\tTargetMethod{name='InnerClass', cutpoint=null, resultType=null, formalParams=(Deque arg), text=(empty)}\n" +
             "}\n";
-    String actual = targetsMap.toString();
-    System.out.println(actual);
     assertEquals(expected, actual);
   }
 
   @Test
   public void methodBodiesAreRecognizedFully() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/MethodBodies.java";
-    TargetsMap targetsMap = loadDroplet(dropletPath);
-    String expected = "MethodBodies -> {\n" +
+    TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
+    String actual = targetsMap.toString();
+    System.out.println(actual);
+    String expected = "ru.ftc.upc.testing.dropper.lang.droplets.MethodBodies -> {\n" +
             "\tTargetMethod{name='MethodBodies', cutpoint=null, resultType=null, formalParams=(String name), text=\n" +
             "\t\tSystem . out . println ( \"Hello from constructor :) \" ) ;\n" +
             "\t}\n" +
@@ -101,16 +105,16 @@ public void methodBodiesAreRecognizedFully() throws Exception {
             "\t\tif ( Math . random ( ) > 0.5d ) { return true ; } else { return false ; }\n" +
             "\t}\n" +
             "}\n";
-    String actual = targetsMap.toString();
-    System.out.println(actual);
     assertEquals(expected, actual);
   }
 
   @Test
   public void enumTypesAreRecognizedFully() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/RootEnumeration.java";
-    TargetsMap targetsMap = loadDroplet(dropletPath);
-    String expected = "RootEnumeration -> {\n" +
+    TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
+    String actual = targetsMap.toString();
+    System.out.println(actual);
+    String expected = "ru.ftc.upc.testing.dropper.lang.droplets.RootEnumeration -> {\n" +
             "\tTargetMethod{name='RootEnumeration', cutpoint=null, resultType=null, formalParams=(), text=\n" +
             "\t\tString nothing = \"I'm the most enumerated constructor ever!\" ;\n" +
             "\t}\n" +
@@ -118,21 +122,21 @@ public void enumTypesAreRecognizedFully() throws Exception {
             "\t\tfor ( RootEnumeration rootEnum : values ( ) ) { if ( rootEnum . toString ( ) . equals ( name ) ) { return rootEnum ; } } throw new IllegalArgumentException ( \"Not found: \" + name ) ;\n" +
             "\t}\n" +
             "}\n" +
-            "RootEnumeration.InnerEnum -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.droplets.RootEnumeration$InnerEnum -> {\n" +
             "\tTargetMethod{name='isTheSame', cutpoint=null, resultType=boolean, formalParams=(Enum e), text=\n" +
             "\t\treturn INNER_ENUM . toString ( ) . equals ( e . toString ( ) ) ;\n" +
             "\t}\n" +
             "}\n";
-    String actual = targetsMap.toString();
-    System.out.println(actual);
     assertEquals(expected, actual);
   }
 
   @Test
   public void interfaceTypesAreRecognizedFully() throws Exception {
     String dropletPath = "src/test/resources/RootInterface.java";
-    TargetsMap targetsMap = loadDroplet(dropletPath);
-    String expected = "RootInterface -> {\n" +
+    TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
+    String actual = targetsMap.toString();
+    System.out.println(actual);
+    String expected = "ru.ftc.upc.testing.dropper.lang.RootInterface -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=null, resultType=void, formalParams=(), text=(empty)}\n" +
             "\tTargetMethod{name='method2', cutpoint=null, resultType=boolean, formalParams=(int two), text=(empty)}\n" +
             "\tTargetMethod{name='method3', cutpoint=null, resultType=RootInterface, formalParams=(Set longs), text=(empty)}\n" +
@@ -143,76 +147,107 @@ public void interfaceTypesAreRecognizedFully() throws Exception {
             "\t\treturn new Observable ( ) ;\n" +
             "\t}\n" +
             "}\n" +
-            "RootInterface.InnerIface -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.RootInterface$InnerIface -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=null, resultType=InputStream, formalParams=(), text=\n" +
             "\t\treturn new FileInputStream ( \"\" ) ;\n" +
             "\t}\n" +
             "}\n" +
-            "RootInterface.InnerIface.InnerInnerIface -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.RootInterface$InnerIface$InnerInnerIface -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=null, resultType=OutputStream, formalParams=(), text=\n" +
             "\t\treturn new FileOutputStream ( \"\" ) ;\n" +
             "\t}\n" +
             "}\n";
-    String actual = targetsMap.toString();
-    System.out.println(actual);
     assertEquals(expected, actual);
   }
 
   @Test
   public void typesCombinationsAreRecognizedFully() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/TypesCombination.java";
-    TargetsMap targetsMap = loadDroplet(dropletPath);
-
+    TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     System.out.println(actual);
-    String expected = "SiblingClass -> {\n" +
+    String expected = "ru.ftc.upc.testing.dropper.lang.droplets.SiblingClass -> {\n" +
             "\tTargetMethod{name='method', cutpoint=null, resultType=double, formalParams=(), text=\n" +
             "\t\treturn Math . random ( ) ;\n" +
             "\t}\n" +
             "}\n" +
-            "SiblingEnum -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.droplets.SiblingEnum -> {\n" +
             "\tTargetMethod{name='SiblingEnum', cutpoint=null, resultType=null, formalParams=(), text=(empty)}\n" +
             "\tTargetMethod{name='getMe', cutpoint=null, resultType=SiblingEnum, formalParams=(), text=\n" +
             "\t\treturn this ;\n" +
             "\t}\n" +
             "}\n" +
-            "SiblingEnum.InnerInterface -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.droplets.SiblingEnum$InnerInterface -> {\n" +
             "\tTargetMethod{name='getThatEnum', cutpoint=null, resultType=TypesCombination.InnerInterface.InnerInnerClass.InnerInnerInnerEnum, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "SiblingInterface -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.droplets.SiblingInterface -> {\n" +
             "\tTargetMethod{name='method', cutpoint=null, resultType=Vector, formalParams=(Vector arg), text=(empty)}\n" +
             "}\n" +
-            "SiblingInterface.InnerEnum -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.droplets.SiblingInterface$InnerEnum -> {\n" +
             "\tTargetMethod{name='InnerEnum', cutpoint=null, resultType=null, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "TypesCombination -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.droplets.TypesCombination -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=null, resultType=void, formalParams=(), text=\n" +
             "\t\tSystem . console ( ) ;\n" +
             "\t}\n" +
             "}\n" +
-            "TypesCombination.InnerInterface -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.droplets.TypesCombination$InnerInterface -> {\n" +
             "\tTargetMethod{name='innerMethod', cutpoint=null, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "TypesCombination.InnerInterface.InnerInnerClass -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.droplets.TypesCombination$InnerInterface$InnerInnerClass -> {\n" +
             "\tTargetMethod{name='innerInnerMethod', cutpoint=null, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "TypesCombination.InnerInterface.InnerInnerClass.InnerInnerInnerEnum -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.droplets.TypesCombination$InnerInterface$InnerInnerClass$InnerInnerInnerEnum -> {\n" +
             "\tTargetMethod{name='doSomething', cutpoint=null, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n";
     assertEquals(expected, actual);
   }
 
-  private TargetsMap loadDroplet(String dropletPath) throws IOException {
+  @Test
+  public void importMapIsComposedCorrectly() throws Exception {
+    String dropletPath = "src/test/resources/Imports.java";
+    Map<String, String> importsMap = loadDroplet(dropletPath).getImportsMap();
+    String expected = "\tCurrency -> java.util\n" +
+            "\tBASE64Encoder -> sun.misc\n";
+    String actual = map2Str(importsMap);
+    System.out.println(actual);
+    assertEquals(expected, actual);
+  }
+
+  @Test(expected = DropletFormatException.class)
+  public void importsOnDemandAreNotSupported() throws Exception {
+    String dropletPath = "src/test/resources/FaultyImports.java";
+    Map<String, String> importsMap = loadDroplet(dropletPath).getImportsMap();
+
+    String actual = map2Str(importsMap);
+    System.out.println(actual);
+  }
+
+  private DropletAssembler loadDroplet(String dropletPath) throws IOException {
     ANTLRFileStream fileStream = new ANTLRFileStream(dropletPath);
     DroppingJavaLexer lexer = new DroppingJavaLexer(fileStream);
     TokenStream tokenStream = new CommonTokenStream(lexer);
     DroppingJavaParser parser = new DroppingJavaParser(tokenStream);
     ParseTree tree = parser.compilationUnit();
 
-    DropperTreeListener listener = new DropperTreeListener();
+    DropletAssembler listener = new DropletAssembler();
     ParseTreeWalker walker = new ParseTreeWalker();
     walker.walk(listener, tree);
 
-    return listener.getTargetsMap();
+    return listener;
+  }
+
+  private String map2Str(Map<String, String> map) {
+    Set<Map.Entry<String, String>> entries = map.entrySet();
+    StringBuilder sb = new StringBuilder();
+    for (Map.Entry<String, String> entry : entries) {
+      sb
+              .append("\t")
+              .append(entry.getKey())
+              .append(" -> ")
+              .append(entry.getValue())
+              .append("\n");
+    }
+    return sb.toString();
   }
 }
\ No newline at end of file
diff --git a/src/test/resources/FaultyImports.java b/src/test/resources/FaultyImports.java
new file mode 100644
index 0000000..358f7ad
--- /dev/null
+++ b/src/test/resources/FaultyImports.java
@@ -0,0 +1,13 @@
+package ru.ftc.upc.testing.dropper.lang.droplets;
+
+import java.util.Currency;
+import Object;
+import sun.misc.BASE64Encoder;
+import java.applet.*;           // the reason of test fail
+
+class Imports {
+
+  public FaultyImports() {
+    System.out.println();
+  }
+}
\ No newline at end of file
diff --git a/src/test/resources/Imports.java b/src/test/resources/Imports.java
new file mode 100644
index 0000000..2126b00
--- /dev/null
+++ b/src/test/resources/Imports.java
@@ -0,0 +1,12 @@
+package ru.ftc.upc.testing.dropper.lang.droplets;
+
+import java.util.Currency;
+import Object;                  // must be ignored by assembler
+import sun.misc.BASE64Encoder;
+
+class Imports {
+
+  public Imports() {
+    System.out.println();
+  }
+}
\ No newline at end of file
diff --git a/src/test/resources/RootInterface.java b/src/test/resources/RootInterface.java
index edc79b0..1aecccc 100644
--- a/src/test/resources/RootInterface.java
+++ b/src/test/resources/RootInterface.java
@@ -1,6 +1,9 @@
 package ru.ftc.upc.testing.dropper.lang;
 
-import java.io.*;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
 import java.util.List;
 import java.util.Observable;
 import java.util.Set;

From 54801f63d3cf39951efda4c1986433cd3a3df936 Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Thu, 2 Jun 2016 00:59:18 +0600
Subject: [PATCH 07/22] UPCSEC-0000 Started implementation of javadoc-style
 cutpoint declarations

---
 .../ru/ftc/upc/testing/dropper/Cutpoint.java  |    5 +-
 .../dropper/lang/CutpointAssembler.java       |   37 +
 .../dropper/lang/DropletAssembler.java        |    1 +
 .../upc/testing/dropper/lang/JavadocLexer.g4  |   79 +
 .../upc/testing/dropper/lang/JavadocParser.g4 |  149 ++
 .../dropper/lang/gen/JavadocLexer.java        |  152 ++
 .../dropper/lang/gen/JavadocLexer.tokens      |   18 +
 .../dropper/lang/gen/JavadocParser.java       | 1887 +++++++++++++++++
 .../dropper/lang/gen/JavadocParser.tokens     |   18 +
 .../lang/gen/JavadocParserBaseListener.java   |  303 +++
 .../lang/gen/JavadocParserBaseVisitor.java    |  168 ++
 .../lang/gen/JavadocParserListener.java       |  230 ++
 .../lang/gen/JavadocParserVisitor.java        |  145 ++
 .../dropper/{lang => model}/TargetsMap.java   |    4 +-
 .../dropper/lang/CutpointAssemblerTest.java   |   81 +
 .../dropper/lang/DropletAssemblerTest.java    |    1 +
 src/test/resources/Cutpoint_1.javadoc         |    8 +
 src/test/resources/Cutpoint_2.javadoc         |    8 +
 src/test/resources/Cutpoint_3.javadoc         |    8 +
 src/test/resources/Cutpoint_4.javadoc         |    8 +
 src/test/resources/Cutpoint_5.javadoc         |    8 +
 21 files changed, 3313 insertions(+), 5 deletions(-)
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/CutpointAssembler.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/JavadocLexer.g4
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/JavadocParser.g4
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocLexer.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocLexer.tokens
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParser.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParser.tokens
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserBaseListener.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserBaseVisitor.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserListener.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserVisitor.java
 rename src/main/java/ru/ftc/upc/testing/dropper/{lang => model}/TargetsMap.java (90%)
 create mode 100644 src/test/java/ru/ftc/upc/testing/dropper/lang/CutpointAssemblerTest.java
 create mode 100644 src/test/resources/Cutpoint_1.javadoc
 create mode 100644 src/test/resources/Cutpoint_2.javadoc
 create mode 100644 src/test/resources/Cutpoint_3.javadoc
 create mode 100644 src/test/resources/Cutpoint_4.javadoc
 create mode 100644 src/test/resources/Cutpoint_5.javadoc

diff --git a/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java b/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java
index edf3deb..f68637e 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java
@@ -3,11 +3,12 @@
 /**
  * Created by Plizga on 29.04.2016 11:59
  */
-@SuppressWarnings("unused")       // все элементы перечисления на самом деле используются через метод Enum#valueOf()
+@SuppressWarnings("unused")       // all the elements of the Enum is actually used through Enum#valueOf()
 public enum Cutpoint {
   BEFORE(BeforeMethodPatcher.class),
   INSTEAD(InsteadMethodPatcher.class),
-  AFTER(AfterMethodPatcher.class);
+  AFTER(AfterMethodPatcher.class),
+  CATCH(MethodPatcher.class);           // TODO implement dedicated patcher
 
   final Class<? extends MethodPatcher> patcherClass;
 
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/CutpointAssembler.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/CutpointAssembler.java
new file mode 100644
index 0000000..18c0061
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/CutpointAssembler.java
@@ -0,0 +1,37 @@
+package ru.ftc.upc.testing.dropper.lang;
+
+import ru.ftc.upc.testing.dropper.lang.gen.JavadocParser;
+import ru.ftc.upc.testing.dropper.lang.gen.JavadocParserBaseListener;
+
+import java.util.List;
+
+/**
+ * @author Toparvion
+ */
+public class CutpointAssembler extends JavadocParserBaseListener {
+
+  private static final String CUTPOINT_TAG_NAME = "cutpoint";
+
+  private String tagValue;
+
+  @Override
+  public void enterBlockTag(JavadocParser.BlockTagContext ctx) {
+    String tagName = ctx.blockTagName().getText();
+    if (!CUTPOINT_TAG_NAME.equalsIgnoreCase(tagName))
+      return;
+
+    List<JavadocParser.BlockTagContentContext> tagContents = ctx.blockTagContent();
+    if (tagContents.isEmpty())
+      return;
+
+    JavadocParser.BlockTagContentContext tagContent = tagContents.get(0);
+    String tagContentText = tagContent.getText();
+    String[] tagValueEntries = tagContentText.split("[\\x20\\t]");
+    /* For the time being we don't support parametrized tag values, but we assume their support in future. */
+    tagValue = tagValueEntries[0];
+  }
+
+  public String getTagValue() {
+    return tagValue;
+  }
+}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
index 6912e16..5b3a340 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
@@ -8,6 +8,7 @@
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaVisitor;
 import ru.ftc.upc.testing.dropper.model.Argument;
 import ru.ftc.upc.testing.dropper.model.TargetMethod;
+import ru.ftc.upc.testing.dropper.model.TargetsMap;
 
 import java.util.*;
 
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/JavadocLexer.g4 b/src/main/java/ru/ftc/upc/testing/dropper/lang/JavadocLexer.g4
new file mode 100644
index 0000000..2cde3f3
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/JavadocLexer.g4
@@ -0,0 +1,79 @@
+/*
+ [The "BSD licence"]
+ Copyright (c) 2016 Pascal Gruen
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+ 3. The name of the author may not be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+lexer grammar JavadocLexer;
+
+NAME
+	: [a-zA-Z]+
+	;
+
+NEWLINE
+	: '\n' (SPACE? (STAR {_input.LA(1) != '/'}?)+)?
+	| '\r\n' (SPACE? (STAR {_input.LA(1) != '/'}?)+)?
+	| '\r' (SPACE? (STAR {_input.LA(1) != '/'}?)+)?
+	;
+
+SPACE
+	: (' '|'\t')+
+	;
+
+TEXT_CONTENT
+	: ~[\n\r\t @*{}/a-zA-Z]+
+	;
+
+AT
+	: '@'
+	;
+
+STAR
+	: '*'
+	;
+
+SLASH
+	: '/'
+	;
+
+JAVADOC_START
+	: '/**' STAR*
+	;
+
+JAVADOC_END
+	: SPACE? STAR* '*/'
+	;
+
+INLINE_TAG_START
+	: '{@'
+	;
+
+BRACE_OPEN
+	: '{'
+	;
+
+BRACE_CLOSE
+	: '}'
+	;
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/JavadocParser.g4 b/src/main/java/ru/ftc/upc/testing/dropper/lang/JavadocParser.g4
new file mode 100644
index 0000000..5027e5b
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/JavadocParser.g4
@@ -0,0 +1,149 @@
+/*
+ [The "BSD licence"]
+ Copyright (c) 2016 Pascal Gruen
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+ 3. The name of the author may not be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+parser grammar JavadocParser;
+
+options { tokenVocab=JavadocLexer; }
+
+
+documentation
+	: EOF
+	| JAVADOC_START skipWhitespace* documentationContent JAVADOC_END EOF
+	| skipWhitespace* documentationContent EOF
+	;
+
+documentationContent
+	: description skipWhitespace*
+	| skipWhitespace* tagSection
+	| description NEWLINE+ skipWhitespace* tagSection
+	;
+
+skipWhitespace
+	: SPACE
+	| NEWLINE
+	;
+
+
+description
+	: descriptionLine (descriptionNewline+ descriptionLine)*
+	;
+
+descriptionLine
+	: descriptionLineStart descriptionLineElement*
+	| inlineTag descriptionLineElement*
+	;
+
+descriptionLineStart
+	: SPACE? descriptionLineNoSpaceNoAt+ (descriptionLineNoSpaceNoAt | SPACE | AT)*
+	;
+
+descriptionLineNoSpaceNoAt
+	: TEXT_CONTENT
+	| NAME
+	| STAR
+	| SLASH
+	| BRACE_OPEN
+	| BRACE_CLOSE
+	;
+
+descriptionLineElement
+	: inlineTag
+	| descriptionLineText
+	;
+
+descriptionLineText
+	: (descriptionLineNoSpaceNoAt | SPACE | AT)+
+	;
+
+descriptionNewline
+	: NEWLINE
+	;
+
+
+tagSection
+	: blockTag+
+	;
+
+blockTag
+	: SPACE? AT blockTagName SPACE? blockTagContent*
+	;
+
+blockTagName
+	: NAME
+	;
+
+blockTagContent
+	: blockTagText
+	| inlineTag
+	| NEWLINE
+	;
+
+blockTagText
+	: blockTagTextElement+
+	;
+
+blockTagTextElement
+	: TEXT_CONTENT
+	| NAME
+	| SPACE
+	| STAR
+	| SLASH
+	| BRACE_OPEN
+	| BRACE_CLOSE
+	;
+
+
+inlineTag
+	: INLINE_TAG_START inlineTagName SPACE* inlineTagContent? BRACE_CLOSE
+	;
+
+inlineTagName
+	: NAME
+	;
+
+inlineTagContent
+	: braceContent+
+	;
+
+braceExpression
+	: BRACE_OPEN braceContent* BRACE_CLOSE
+	;
+
+braceContent
+	: braceExpression
+	| braceText (NEWLINE* braceText)*
+	;
+
+braceText
+	: TEXT_CONTENT
+	| NAME
+	| SPACE
+	| STAR
+	| SLASH
+	| NEWLINE
+	;
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocLexer.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocLexer.java
new file mode 100644
index 0000000..0174ed7
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocLexer.java
@@ -0,0 +1,152 @@
+// Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\JavadocLexer.g4 by ANTLR 4.5.1
+package ru.ftc.upc.testing.dropper.lang.gen;
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.atn.ATN;
+import org.antlr.v4.runtime.atn.ATNDeserializer;
+import org.antlr.v4.runtime.atn.LexerATNSimulator;
+import org.antlr.v4.runtime.atn.PredictionContextCache;
+import org.antlr.v4.runtime.dfa.DFA;
+
+@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
+public class JavadocLexer extends Lexer {
+	static { RuntimeMetaData.checkVersion("4.5.1", RuntimeMetaData.VERSION); }
+
+	protected static final DFA[] _decisionToDFA;
+	protected static final PredictionContextCache _sharedContextCache =
+		new PredictionContextCache();
+	public static final int
+		NAME=1, NEWLINE=2, SPACE=3, TEXT_CONTENT=4, AT=5, STAR=6, SLASH=7, JAVADOC_START=8, 
+		JAVADOC_END=9, INLINE_TAG_START=10, BRACE_OPEN=11, BRACE_CLOSE=12;
+	public static String[] modeNames = {
+		"DEFAULT_MODE"
+	};
+
+	public static final String[] ruleNames = {
+		"NAME", "NEWLINE", "SPACE", "TEXT_CONTENT", "AT", "STAR", "SLASH", "JAVADOC_START", 
+		"JAVADOC_END", "INLINE_TAG_START", "BRACE_OPEN", "BRACE_CLOSE"
+	};
+
+	private static final String[] _LITERAL_NAMES = {
+		null, null, null, null, null, "'@'", "'*'", "'/'", null, null, "'{@'", 
+		"'{'", "'}'"
+	};
+	private static final String[] _SYMBOLIC_NAMES = {
+		null, "NAME", "NEWLINE", "SPACE", "TEXT_CONTENT", "AT", "STAR", "SLASH", 
+		"JAVADOC_START", "JAVADOC_END", "INLINE_TAG_START", "BRACE_OPEN", "BRACE_CLOSE"
+	};
+	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
+
+	/**
+	 * @deprecated Use {@link #VOCABULARY} instead.
+	 */
+	@Deprecated
+	public static final String[] tokenNames;
+	static {
+		tokenNames = new String[_SYMBOLIC_NAMES.length];
+		for (int i = 0; i < tokenNames.length; i++) {
+			tokenNames[i] = VOCABULARY.getLiteralName(i);
+			if (tokenNames[i] == null) {
+				tokenNames[i] = VOCABULARY.getSymbolicName(i);
+			}
+
+			if (tokenNames[i] == null) {
+				tokenNames[i] = "<INVALID>";
+			}
+		}
+	}
+
+	@Override
+	@Deprecated
+	public String[] getTokenNames() {
+		return tokenNames;
+	}
+
+	@Override
+
+	public Vocabulary getVocabulary() {
+		return VOCABULARY;
+	}
+
+
+	public JavadocLexer(CharStream input) {
+		super(input);
+		_interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
+	}
+
+	@Override
+	public String getGrammarFileName() { return "JavadocLexer.g4"; }
+
+	@Override
+	public String[] getRuleNames() { return ruleNames; }
+
+	@Override
+	public String getSerializedATN() { return _serializedATN; }
+
+	@Override
+	public String[] getModeNames() { return modeNames; }
+
+	@Override
+	public ATN getATN() { return _ATN; }
+
+	@Override
+	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
+		switch (ruleIndex) {
+		case 1:
+			return NEWLINE_sempred((RuleContext)_localctx, predIndex);
+		}
+		return true;
+	}
+	private boolean NEWLINE_sempred(RuleContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 0:
+			return _input.LA(1) != '/';
+		case 1:
+			return _input.LA(1) != '/';
+		case 2:
+			return _input.LA(1) != '/';
+		}
+		return true;
+	}
+
+	public static final String _serializedATN =
+		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2\16x\b\1\4\2\t\2\4"+
+		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
+		"\13\4\f\t\f\4\r\t\r\3\2\6\2\35\n\2\r\2\16\2\36\3\3\3\3\5\3#\n\3\3\3\3"+
+		"\3\3\3\6\3(\n\3\r\3\16\3)\5\3,\n\3\3\3\3\3\3\3\3\3\5\3\62\n\3\3\3\3\3"+
+		"\3\3\6\3\67\n\3\r\3\16\38\5\3;\n\3\3\3\3\3\5\3?\n\3\3\3\3\3\3\3\6\3D\n"+
+		"\3\r\3\16\3E\5\3H\n\3\5\3J\n\3\3\4\6\4M\n\4\r\4\16\4N\3\5\6\5R\n\5\r\5"+
+		"\16\5S\3\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\3\t\3\t\3\t\7\ta\n\t\f\t\16\td"+
+		"\13\t\3\n\5\ng\n\n\3\n\7\nj\n\n\f\n\16\nm\13\n\3\n\3\n\3\n\3\13\3\13\3"+
+		"\13\3\f\3\f\3\r\3\r\2\2\16\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25"+
+		"\f\27\r\31\16\3\2\5\4\2C\\c|\4\2\13\13\"\"\n\2\13\f\17\17\"\",,\61\61"+
+		"B\\c}\177\177\u0088\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2"+
+		"\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3"+
+		"\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\3\34\3\2\2\2\5I\3\2\2\2\7L\3\2\2\2\t"+
+		"Q\3\2\2\2\13U\3\2\2\2\rW\3\2\2\2\17Y\3\2\2\2\21[\3\2\2\2\23f\3\2\2\2\25"+
+		"q\3\2\2\2\27t\3\2\2\2\31v\3\2\2\2\33\35\t\2\2\2\34\33\3\2\2\2\35\36\3"+
+		"\2\2\2\36\34\3\2\2\2\36\37\3\2\2\2\37\4\3\2\2\2 +\7\f\2\2!#\5\7\4\2\""+
+		"!\3\2\2\2\"#\3\2\2\2#\'\3\2\2\2$%\5\r\7\2%&\6\3\2\2&(\3\2\2\2\'$\3\2\2"+
+		"\2()\3\2\2\2)\'\3\2\2\2)*\3\2\2\2*,\3\2\2\2+\"\3\2\2\2+,\3\2\2\2,J\3\2"+
+		"\2\2-.\7\17\2\2./\7\f\2\2/:\3\2\2\2\60\62\5\7\4\2\61\60\3\2\2\2\61\62"+
+		"\3\2\2\2\62\66\3\2\2\2\63\64\5\r\7\2\64\65\6\3\3\2\65\67\3\2\2\2\66\63"+
+		"\3\2\2\2\678\3\2\2\28\66\3\2\2\289\3\2\2\29;\3\2\2\2:\61\3\2\2\2:;\3\2"+
+		"\2\2;J\3\2\2\2<G\7\17\2\2=?\5\7\4\2>=\3\2\2\2>?\3\2\2\2?C\3\2\2\2@A\5"+
+		"\r\7\2AB\6\3\4\2BD\3\2\2\2C@\3\2\2\2DE\3\2\2\2EC\3\2\2\2EF\3\2\2\2FH\3"+
+		"\2\2\2G>\3\2\2\2GH\3\2\2\2HJ\3\2\2\2I \3\2\2\2I-\3\2\2\2I<\3\2\2\2J\6"+
+		"\3\2\2\2KM\t\3\2\2LK\3\2\2\2MN\3\2\2\2NL\3\2\2\2NO\3\2\2\2O\b\3\2\2\2"+
+		"PR\n\4\2\2QP\3\2\2\2RS\3\2\2\2SQ\3\2\2\2ST\3\2\2\2T\n\3\2\2\2UV\7B\2\2"+
+		"V\f\3\2\2\2WX\7,\2\2X\16\3\2\2\2YZ\7\61\2\2Z\20\3\2\2\2[\\\7\61\2\2\\"+
+		"]\7,\2\2]^\7,\2\2^b\3\2\2\2_a\5\r\7\2`_\3\2\2\2ad\3\2\2\2b`\3\2\2\2bc"+
+		"\3\2\2\2c\22\3\2\2\2db\3\2\2\2eg\5\7\4\2fe\3\2\2\2fg\3\2\2\2gk\3\2\2\2"+
+		"hj\5\r\7\2ih\3\2\2\2jm\3\2\2\2ki\3\2\2\2kl\3\2\2\2ln\3\2\2\2mk\3\2\2\2"+
+		"no\7,\2\2op\7\61\2\2p\24\3\2\2\2qr\7}\2\2rs\7B\2\2s\26\3\2\2\2tu\7}\2"+
+		"\2u\30\3\2\2\2vw\7\177\2\2w\32\3\2\2\2\23\2\36\")+\618:>EGINSbfk\2";
+	public static final ATN _ATN =
+		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
+	static {
+		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
+		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
+			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocLexer.tokens b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocLexer.tokens
new file mode 100644
index 0000000..39ad57e
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocLexer.tokens
@@ -0,0 +1,18 @@
+NAME=1
+NEWLINE=2
+SPACE=3
+TEXT_CONTENT=4
+AT=5
+STAR=6
+SLASH=7
+JAVADOC_START=8
+JAVADOC_END=9
+INLINE_TAG_START=10
+BRACE_OPEN=11
+BRACE_CLOSE=12
+'@'=5
+'*'=6
+'/'=7
+'{@'=10
+'{'=11
+'}'=12
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParser.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParser.java
new file mode 100644
index 0000000..e42d246
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParser.java
@@ -0,0 +1,1887 @@
+// Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\JavadocParser.g4 by ANTLR 4.5.1
+package ru.ftc.upc.testing.dropper.lang.gen;
+
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.atn.ATN;
+import org.antlr.v4.runtime.atn.ATNDeserializer;
+import org.antlr.v4.runtime.atn.ParserATNSimulator;
+import org.antlr.v4.runtime.atn.PredictionContextCache;
+import org.antlr.v4.runtime.dfa.DFA;
+import org.antlr.v4.runtime.tree.ParseTreeListener;
+import org.antlr.v4.runtime.tree.ParseTreeVisitor;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+import java.util.List;
+
+@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
+public class JavadocParser extends Parser {
+	static { RuntimeMetaData.checkVersion("4.5.1", RuntimeMetaData.VERSION); }
+
+	protected static final DFA[] _decisionToDFA;
+	protected static final PredictionContextCache _sharedContextCache =
+		new PredictionContextCache();
+	public static final int
+		NAME=1, NEWLINE=2, SPACE=3, TEXT_CONTENT=4, AT=5, STAR=6, SLASH=7, JAVADOC_START=8, 
+		JAVADOC_END=9, INLINE_TAG_START=10, BRACE_OPEN=11, BRACE_CLOSE=12;
+	public static final int
+		RULE_documentation = 0, RULE_documentationContent = 1, RULE_skipWhitespace = 2, 
+		RULE_description = 3, RULE_descriptionLine = 4, RULE_descriptionLineStart = 5, 
+		RULE_descriptionLineNoSpaceNoAt = 6, RULE_descriptionLineElement = 7, 
+		RULE_descriptionLineText = 8, RULE_descriptionNewline = 9, RULE_tagSection = 10, 
+		RULE_blockTag = 11, RULE_blockTagName = 12, RULE_blockTagContent = 13, 
+		RULE_blockTagText = 14, RULE_blockTagTextElement = 15, RULE_inlineTag = 16, 
+		RULE_inlineTagName = 17, RULE_inlineTagContent = 18, RULE_braceExpression = 19, 
+		RULE_braceContent = 20, RULE_braceText = 21;
+	public static final String[] ruleNames = {
+		"documentation", "documentationContent", "skipWhitespace", "description", 
+		"descriptionLine", "descriptionLineStart", "descriptionLineNoSpaceNoAt", 
+		"descriptionLineElement", "descriptionLineText", "descriptionNewline", 
+		"tagSection", "blockTag", "blockTagName", "blockTagContent", "blockTagText", 
+		"blockTagTextElement", "inlineTag", "inlineTagName", "inlineTagContent", 
+		"braceExpression", "braceContent", "braceText"
+	};
+
+	private static final String[] _LITERAL_NAMES = {
+		null, null, null, null, null, "'@'", "'*'", "'/'", null, null, "'{@'", 
+		"'{'", "'}'"
+	};
+	private static final String[] _SYMBOLIC_NAMES = {
+		null, "NAME", "NEWLINE", "SPACE", "TEXT_CONTENT", "AT", "STAR", "SLASH", 
+		"JAVADOC_START", "JAVADOC_END", "INLINE_TAG_START", "BRACE_OPEN", "BRACE_CLOSE"
+	};
+	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
+
+	/**
+	 * @deprecated Use {@link #VOCABULARY} instead.
+	 */
+	@Deprecated
+	public static final String[] tokenNames;
+	static {
+		tokenNames = new String[_SYMBOLIC_NAMES.length];
+		for (int i = 0; i < tokenNames.length; i++) {
+			tokenNames[i] = VOCABULARY.getLiteralName(i);
+			if (tokenNames[i] == null) {
+				tokenNames[i] = VOCABULARY.getSymbolicName(i);
+			}
+
+			if (tokenNames[i] == null) {
+				tokenNames[i] = "<INVALID>";
+			}
+		}
+	}
+
+	@Override
+	@Deprecated
+	public String[] getTokenNames() {
+		return tokenNames;
+	}
+
+	@Override
+
+	public Vocabulary getVocabulary() {
+		return VOCABULARY;
+	}
+
+	@Override
+	public String getGrammarFileName() { return "JavadocParser.g4"; }
+
+	@Override
+	public String[] getRuleNames() { return ruleNames; }
+
+	@Override
+	public String getSerializedATN() { return _serializedATN; }
+
+	@Override
+	public ATN getATN() { return _ATN; }
+
+	public JavadocParser(TokenStream input) {
+		super(input);
+		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
+	}
+	public static class DocumentationContext extends ParserRuleContext {
+		public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); }
+		public TerminalNode JAVADOC_START() { return getToken(JavadocParser.JAVADOC_START, 0); }
+		public DocumentationContentContext documentationContent() {
+			return getRuleContext(DocumentationContentContext.class,0);
+		}
+		public TerminalNode JAVADOC_END() { return getToken(JavadocParser.JAVADOC_END, 0); }
+		public List<SkipWhitespaceContext> skipWhitespace() {
+			return getRuleContexts(SkipWhitespaceContext.class);
+		}
+		public SkipWhitespaceContext skipWhitespace(int i) {
+			return getRuleContext(SkipWhitespaceContext.class,i);
+		}
+		public DocumentationContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_documentation; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDocumentation(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDocumentation(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDocumentation(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final DocumentationContext documentation() throws RecognitionException {
+		DocumentationContext _localctx = new DocumentationContext(_ctx, getState());
+		enterRule(_localctx, 0, RULE_documentation);
+		try {
+			int _alt;
+			setState(65);
+			switch (_input.LA(1)) {
+			case EOF:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(44);
+				match(EOF);
+				}
+				break;
+			case JAVADOC_START:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(45);
+				match(JAVADOC_START);
+				setState(49);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
+				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+					if ( _alt==1 ) {
+						{
+						{
+						setState(46);
+						skipWhitespace();
+						}
+						} 
+					}
+					setState(51);
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
+				}
+				setState(52);
+				documentationContent();
+				setState(53);
+				match(JAVADOC_END);
+				setState(54);
+				match(EOF);
+				}
+				break;
+			case NAME:
+			case NEWLINE:
+			case SPACE:
+			case TEXT_CONTENT:
+			case AT:
+			case STAR:
+			case SLASH:
+			case INLINE_TAG_START:
+			case BRACE_OPEN:
+			case BRACE_CLOSE:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(59);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,1,_ctx);
+				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+					if ( _alt==1 ) {
+						{
+						{
+						setState(56);
+						skipWhitespace();
+						}
+						} 
+					}
+					setState(61);
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,1,_ctx);
+				}
+				setState(62);
+				documentationContent();
+				setState(63);
+				match(EOF);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class DocumentationContentContext extends ParserRuleContext {
+		public DescriptionContext description() {
+			return getRuleContext(DescriptionContext.class,0);
+		}
+		public List<SkipWhitespaceContext> skipWhitespace() {
+			return getRuleContexts(SkipWhitespaceContext.class);
+		}
+		public SkipWhitespaceContext skipWhitespace(int i) {
+			return getRuleContext(SkipWhitespaceContext.class,i);
+		}
+		public TagSectionContext tagSection() {
+			return getRuleContext(TagSectionContext.class,0);
+		}
+		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
+		public TerminalNode NEWLINE(int i) {
+			return getToken(JavadocParser.NEWLINE, i);
+		}
+		public DocumentationContentContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_documentationContent; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDocumentationContent(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDocumentationContent(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDocumentationContent(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final DocumentationContentContext documentationContent() throws RecognitionException {
+		DocumentationContentContext _localctx = new DocumentationContentContext(_ctx, getState());
+		enterRule(_localctx, 2, RULE_documentationContent);
+		int _la;
+		try {
+			int _alt;
+			setState(95);
+			switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(67);
+				description();
+				setState(71);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==NEWLINE || _la==SPACE) {
+					{
+					{
+					setState(68);
+					skipWhitespace();
+					}
+					}
+					setState(73);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(77);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
+				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+					if ( _alt==1 ) {
+						{
+						{
+						setState(74);
+						skipWhitespace();
+						}
+						} 
+					}
+					setState(79);
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
+				}
+				setState(80);
+				tagSection();
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(81);
+				description();
+				setState(83); 
+				_errHandler.sync(this);
+				_alt = 1;
+				do {
+					switch (_alt) {
+					case 1:
+						{
+						{
+						setState(82);
+						match(NEWLINE);
+						}
+						}
+						break;
+					default:
+						throw new NoViableAltException(this);
+					}
+					setState(85); 
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
+				} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+				setState(90);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
+				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+					if ( _alt==1 ) {
+						{
+						{
+						setState(87);
+						skipWhitespace();
+						}
+						} 
+					}
+					setState(92);
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
+				}
+				setState(93);
+				tagSection();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class SkipWhitespaceContext extends ParserRuleContext {
+		public TerminalNode SPACE() { return getToken(JavadocParser.SPACE, 0); }
+		public TerminalNode NEWLINE() { return getToken(JavadocParser.NEWLINE, 0); }
+		public SkipWhitespaceContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_skipWhitespace; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSkipWhitespace(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSkipWhitespace(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSkipWhitespace(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final SkipWhitespaceContext skipWhitespace() throws RecognitionException {
+		SkipWhitespaceContext _localctx = new SkipWhitespaceContext(_ctx, getState());
+		enterRule(_localctx, 4, RULE_skipWhitespace);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(97);
+			_la = _input.LA(1);
+			if ( !(_la==NEWLINE || _la==SPACE) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class DescriptionContext extends ParserRuleContext {
+		public List<DescriptionLineContext> descriptionLine() {
+			return getRuleContexts(DescriptionLineContext.class);
+		}
+		public DescriptionLineContext descriptionLine(int i) {
+			return getRuleContext(DescriptionLineContext.class,i);
+		}
+		public List<DescriptionNewlineContext> descriptionNewline() {
+			return getRuleContexts(DescriptionNewlineContext.class);
+		}
+		public DescriptionNewlineContext descriptionNewline(int i) {
+			return getRuleContext(DescriptionNewlineContext.class,i);
+		}
+		public DescriptionContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_description; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescription(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescription(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescription(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final DescriptionContext description() throws RecognitionException {
+		DescriptionContext _localctx = new DescriptionContext(_ctx, getState());
+		enterRule(_localctx, 6, RULE_description);
+		int _la;
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(99);
+			descriptionLine();
+			setState(109);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,9,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(101); 
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+					do {
+						{
+						{
+						setState(100);
+						descriptionNewline();
+						}
+						}
+						setState(103); 
+						_errHandler.sync(this);
+						_la = _input.LA(1);
+					} while ( _la==NEWLINE );
+					setState(105);
+					descriptionLine();
+					}
+					} 
+				}
+				setState(111);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,9,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class DescriptionLineContext extends ParserRuleContext {
+		public DescriptionLineStartContext descriptionLineStart() {
+			return getRuleContext(DescriptionLineStartContext.class,0);
+		}
+		public List<DescriptionLineElementContext> descriptionLineElement() {
+			return getRuleContexts(DescriptionLineElementContext.class);
+		}
+		public DescriptionLineElementContext descriptionLineElement(int i) {
+			return getRuleContext(DescriptionLineElementContext.class,i);
+		}
+		public InlineTagContext inlineTag() {
+			return getRuleContext(InlineTagContext.class,0);
+		}
+		public DescriptionLineContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_descriptionLine; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescriptionLine(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescriptionLine(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescriptionLine(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final DescriptionLineContext descriptionLine() throws RecognitionException {
+		DescriptionLineContext _localctx = new DescriptionLineContext(_ctx, getState());
+		enterRule(_localctx, 8, RULE_descriptionLine);
+		try {
+			int _alt;
+			setState(126);
+			switch (_input.LA(1)) {
+			case NAME:
+			case SPACE:
+			case TEXT_CONTENT:
+			case STAR:
+			case SLASH:
+			case BRACE_OPEN:
+			case BRACE_CLOSE:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(112);
+				descriptionLineStart();
+				setState(116);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
+				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+					if ( _alt==1 ) {
+						{
+						{
+						setState(113);
+						descriptionLineElement();
+						}
+						} 
+					}
+					setState(118);
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
+				}
+				}
+				break;
+			case INLINE_TAG_START:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(119);
+				inlineTag();
+				setState(123);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
+				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+					if ( _alt==1 ) {
+						{
+						{
+						setState(120);
+						descriptionLineElement();
+						}
+						} 
+					}
+					setState(125);
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
+				}
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class DescriptionLineStartContext extends ParserRuleContext {
+		public List<TerminalNode> SPACE() { return getTokens(JavadocParser.SPACE); }
+		public TerminalNode SPACE(int i) {
+			return getToken(JavadocParser.SPACE, i);
+		}
+		public List<DescriptionLineNoSpaceNoAtContext> descriptionLineNoSpaceNoAt() {
+			return getRuleContexts(DescriptionLineNoSpaceNoAtContext.class);
+		}
+		public DescriptionLineNoSpaceNoAtContext descriptionLineNoSpaceNoAt(int i) {
+			return getRuleContext(DescriptionLineNoSpaceNoAtContext.class,i);
+		}
+		public List<TerminalNode> AT() { return getTokens(JavadocParser.AT); }
+		public TerminalNode AT(int i) {
+			return getToken(JavadocParser.AT, i);
+		}
+		public DescriptionLineStartContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_descriptionLineStart; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescriptionLineStart(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescriptionLineStart(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescriptionLineStart(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final DescriptionLineStartContext descriptionLineStart() throws RecognitionException {
+		DescriptionLineStartContext _localctx = new DescriptionLineStartContext(_ctx, getState());
+		enterRule(_localctx, 10, RULE_descriptionLineStart);
+		int _la;
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(129);
+			_la = _input.LA(1);
+			if (_la==SPACE) {
+				{
+				setState(128);
+				match(SPACE);
+				}
+			}
+
+			setState(132); 
+			_errHandler.sync(this);
+			_alt = 1;
+			do {
+				switch (_alt) {
+				case 1:
+					{
+					{
+					setState(131);
+					descriptionLineNoSpaceNoAt();
+					}
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				setState(134); 
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
+			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+			setState(141);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					setState(139);
+					switch (_input.LA(1)) {
+					case NAME:
+					case TEXT_CONTENT:
+					case STAR:
+					case SLASH:
+					case BRACE_OPEN:
+					case BRACE_CLOSE:
+						{
+						setState(136);
+						descriptionLineNoSpaceNoAt();
+						}
+						break;
+					case SPACE:
+						{
+						setState(137);
+						match(SPACE);
+						}
+						break;
+					case AT:
+						{
+						setState(138);
+						match(AT);
+						}
+						break;
+					default:
+						throw new NoViableAltException(this);
+					}
+					} 
+				}
+				setState(143);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class DescriptionLineNoSpaceNoAtContext extends ParserRuleContext {
+		public TerminalNode TEXT_CONTENT() { return getToken(JavadocParser.TEXT_CONTENT, 0); }
+		public TerminalNode NAME() { return getToken(JavadocParser.NAME, 0); }
+		public TerminalNode STAR() { return getToken(JavadocParser.STAR, 0); }
+		public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
+		public TerminalNode BRACE_OPEN() { return getToken(JavadocParser.BRACE_OPEN, 0); }
+		public TerminalNode BRACE_CLOSE() { return getToken(JavadocParser.BRACE_CLOSE, 0); }
+		public DescriptionLineNoSpaceNoAtContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_descriptionLineNoSpaceNoAt; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescriptionLineNoSpaceNoAt(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescriptionLineNoSpaceNoAt(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescriptionLineNoSpaceNoAt(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final DescriptionLineNoSpaceNoAtContext descriptionLineNoSpaceNoAt() throws RecognitionException {
+		DescriptionLineNoSpaceNoAtContext _localctx = new DescriptionLineNoSpaceNoAtContext(_ctx, getState());
+		enterRule(_localctx, 12, RULE_descriptionLineNoSpaceNoAt);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(144);
+			_la = _input.LA(1);
+			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << TEXT_CONTENT) | (1L << STAR) | (1L << SLASH) | (1L << BRACE_OPEN) | (1L << BRACE_CLOSE))) != 0)) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class DescriptionLineElementContext extends ParserRuleContext {
+		public InlineTagContext inlineTag() {
+			return getRuleContext(InlineTagContext.class,0);
+		}
+		public DescriptionLineTextContext descriptionLineText() {
+			return getRuleContext(DescriptionLineTextContext.class,0);
+		}
+		public DescriptionLineElementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_descriptionLineElement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescriptionLineElement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescriptionLineElement(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescriptionLineElement(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final DescriptionLineElementContext descriptionLineElement() throws RecognitionException {
+		DescriptionLineElementContext _localctx = new DescriptionLineElementContext(_ctx, getState());
+		enterRule(_localctx, 14, RULE_descriptionLineElement);
+		try {
+			setState(148);
+			switch (_input.LA(1)) {
+			case INLINE_TAG_START:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(146);
+				inlineTag();
+				}
+				break;
+			case NAME:
+			case SPACE:
+			case TEXT_CONTENT:
+			case AT:
+			case STAR:
+			case SLASH:
+			case BRACE_OPEN:
+			case BRACE_CLOSE:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(147);
+				descriptionLineText();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class DescriptionLineTextContext extends ParserRuleContext {
+		public List<DescriptionLineNoSpaceNoAtContext> descriptionLineNoSpaceNoAt() {
+			return getRuleContexts(DescriptionLineNoSpaceNoAtContext.class);
+		}
+		public DescriptionLineNoSpaceNoAtContext descriptionLineNoSpaceNoAt(int i) {
+			return getRuleContext(DescriptionLineNoSpaceNoAtContext.class,i);
+		}
+		public List<TerminalNode> SPACE() { return getTokens(JavadocParser.SPACE); }
+		public TerminalNode SPACE(int i) {
+			return getToken(JavadocParser.SPACE, i);
+		}
+		public List<TerminalNode> AT() { return getTokens(JavadocParser.AT); }
+		public TerminalNode AT(int i) {
+			return getToken(JavadocParser.AT, i);
+		}
+		public DescriptionLineTextContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_descriptionLineText; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescriptionLineText(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescriptionLineText(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescriptionLineText(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final DescriptionLineTextContext descriptionLineText() throws RecognitionException {
+		DescriptionLineTextContext _localctx = new DescriptionLineTextContext(_ctx, getState());
+		enterRule(_localctx, 16, RULE_descriptionLineText);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(153); 
+			_errHandler.sync(this);
+			_alt = 1;
+			do {
+				switch (_alt) {
+				case 1:
+					{
+					setState(153);
+					switch (_input.LA(1)) {
+					case NAME:
+					case TEXT_CONTENT:
+					case STAR:
+					case SLASH:
+					case BRACE_OPEN:
+					case BRACE_CLOSE:
+						{
+						setState(150);
+						descriptionLineNoSpaceNoAt();
+						}
+						break;
+					case SPACE:
+						{
+						setState(151);
+						match(SPACE);
+						}
+						break;
+					case AT:
+						{
+						setState(152);
+						match(AT);
+						}
+						break;
+					default:
+						throw new NoViableAltException(this);
+					}
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				setState(155); 
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,19,_ctx);
+			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class DescriptionNewlineContext extends ParserRuleContext {
+		public TerminalNode NEWLINE() { return getToken(JavadocParser.NEWLINE, 0); }
+		public DescriptionNewlineContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_descriptionNewline; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescriptionNewline(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescriptionNewline(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescriptionNewline(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final DescriptionNewlineContext descriptionNewline() throws RecognitionException {
+		DescriptionNewlineContext _localctx = new DescriptionNewlineContext(_ctx, getState());
+		enterRule(_localctx, 18, RULE_descriptionNewline);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(157);
+			match(NEWLINE);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TagSectionContext extends ParserRuleContext {
+		public List<BlockTagContext> blockTag() {
+			return getRuleContexts(BlockTagContext.class);
+		}
+		public BlockTagContext blockTag(int i) {
+			return getRuleContext(BlockTagContext.class,i);
+		}
+		public TagSectionContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_tagSection; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTagSection(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTagSection(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTagSection(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final TagSectionContext tagSection() throws RecognitionException {
+		TagSectionContext _localctx = new TagSectionContext(_ctx, getState());
+		enterRule(_localctx, 20, RULE_tagSection);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(160); 
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			do {
+				{
+				{
+				setState(159);
+				blockTag();
+				}
+				}
+				setState(162); 
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			} while ( _la==SPACE || _la==AT );
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class BlockTagContext extends ParserRuleContext {
+		public TerminalNode AT() { return getToken(JavadocParser.AT, 0); }
+		public BlockTagNameContext blockTagName() {
+			return getRuleContext(BlockTagNameContext.class,0);
+		}
+		public List<TerminalNode> SPACE() { return getTokens(JavadocParser.SPACE); }
+		public TerminalNode SPACE(int i) {
+			return getToken(JavadocParser.SPACE, i);
+		}
+		public List<BlockTagContentContext> blockTagContent() {
+			return getRuleContexts(BlockTagContentContext.class);
+		}
+		public BlockTagContentContext blockTagContent(int i) {
+			return getRuleContext(BlockTagContentContext.class,i);
+		}
+		public BlockTagContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_blockTag; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBlockTag(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBlockTag(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBlockTag(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final BlockTagContext blockTag() throws RecognitionException {
+		BlockTagContext _localctx = new BlockTagContext(_ctx, getState());
+		enterRule(_localctx, 22, RULE_blockTag);
+		int _la;
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(165);
+			_la = _input.LA(1);
+			if (_la==SPACE) {
+				{
+				setState(164);
+				match(SPACE);
+				}
+			}
+
+			setState(167);
+			match(AT);
+			setState(168);
+			blockTagName();
+			setState(170);
+			switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
+			case 1:
+				{
+				setState(169);
+				match(SPACE);
+				}
+				break;
+			}
+			setState(175);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,23,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(172);
+					blockTagContent();
+					}
+					} 
+				}
+				setState(177);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,23,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class BlockTagNameContext extends ParserRuleContext {
+		public TerminalNode NAME() { return getToken(JavadocParser.NAME, 0); }
+		public BlockTagNameContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_blockTagName; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBlockTagName(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBlockTagName(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBlockTagName(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final BlockTagNameContext blockTagName() throws RecognitionException {
+		BlockTagNameContext _localctx = new BlockTagNameContext(_ctx, getState());
+		enterRule(_localctx, 24, RULE_blockTagName);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(178);
+			match(NAME);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class BlockTagContentContext extends ParserRuleContext {
+		public BlockTagTextContext blockTagText() {
+			return getRuleContext(BlockTagTextContext.class,0);
+		}
+		public InlineTagContext inlineTag() {
+			return getRuleContext(InlineTagContext.class,0);
+		}
+		public TerminalNode NEWLINE() { return getToken(JavadocParser.NEWLINE, 0); }
+		public BlockTagContentContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_blockTagContent; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBlockTagContent(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBlockTagContent(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBlockTagContent(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final BlockTagContentContext blockTagContent() throws RecognitionException {
+		BlockTagContentContext _localctx = new BlockTagContentContext(_ctx, getState());
+		enterRule(_localctx, 26, RULE_blockTagContent);
+		try {
+			setState(183);
+			switch (_input.LA(1)) {
+			case NAME:
+			case SPACE:
+			case TEXT_CONTENT:
+			case STAR:
+			case SLASH:
+			case BRACE_OPEN:
+			case BRACE_CLOSE:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(180);
+				blockTagText();
+				}
+				break;
+			case INLINE_TAG_START:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(181);
+				inlineTag();
+				}
+				break;
+			case NEWLINE:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(182);
+				match(NEWLINE);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class BlockTagTextContext extends ParserRuleContext {
+		public List<BlockTagTextElementContext> blockTagTextElement() {
+			return getRuleContexts(BlockTagTextElementContext.class);
+		}
+		public BlockTagTextElementContext blockTagTextElement(int i) {
+			return getRuleContext(BlockTagTextElementContext.class,i);
+		}
+		public BlockTagTextContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_blockTagText; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBlockTagText(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBlockTagText(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBlockTagText(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final BlockTagTextContext blockTagText() throws RecognitionException {
+		BlockTagTextContext _localctx = new BlockTagTextContext(_ctx, getState());
+		enterRule(_localctx, 28, RULE_blockTagText);
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(186); 
+			_errHandler.sync(this);
+			_alt = 1;
+			do {
+				switch (_alt) {
+				case 1:
+					{
+					{
+					setState(185);
+					blockTagTextElement();
+					}
+					}
+					break;
+				default:
+					throw new NoViableAltException(this);
+				}
+				setState(188); 
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,25,_ctx);
+			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class BlockTagTextElementContext extends ParserRuleContext {
+		public TerminalNode TEXT_CONTENT() { return getToken(JavadocParser.TEXT_CONTENT, 0); }
+		public TerminalNode NAME() { return getToken(JavadocParser.NAME, 0); }
+		public TerminalNode SPACE() { return getToken(JavadocParser.SPACE, 0); }
+		public TerminalNode STAR() { return getToken(JavadocParser.STAR, 0); }
+		public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
+		public TerminalNode BRACE_OPEN() { return getToken(JavadocParser.BRACE_OPEN, 0); }
+		public TerminalNode BRACE_CLOSE() { return getToken(JavadocParser.BRACE_CLOSE, 0); }
+		public BlockTagTextElementContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_blockTagTextElement; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBlockTagTextElement(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBlockTagTextElement(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBlockTagTextElement(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final BlockTagTextElementContext blockTagTextElement() throws RecognitionException {
+		BlockTagTextElementContext _localctx = new BlockTagTextElementContext(_ctx, getState());
+		enterRule(_localctx, 30, RULE_blockTagTextElement);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(190);
+			_la = _input.LA(1);
+			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << SPACE) | (1L << TEXT_CONTENT) | (1L << STAR) | (1L << SLASH) | (1L << BRACE_OPEN) | (1L << BRACE_CLOSE))) != 0)) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InlineTagContext extends ParserRuleContext {
+		public TerminalNode INLINE_TAG_START() { return getToken(JavadocParser.INLINE_TAG_START, 0); }
+		public InlineTagNameContext inlineTagName() {
+			return getRuleContext(InlineTagNameContext.class,0);
+		}
+		public TerminalNode BRACE_CLOSE() { return getToken(JavadocParser.BRACE_CLOSE, 0); }
+		public List<TerminalNode> SPACE() { return getTokens(JavadocParser.SPACE); }
+		public TerminalNode SPACE(int i) {
+			return getToken(JavadocParser.SPACE, i);
+		}
+		public InlineTagContentContext inlineTagContent() {
+			return getRuleContext(InlineTagContentContext.class,0);
+		}
+		public InlineTagContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_inlineTag; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInlineTag(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInlineTag(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInlineTag(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final InlineTagContext inlineTag() throws RecognitionException {
+		InlineTagContext _localctx = new InlineTagContext(_ctx, getState());
+		enterRule(_localctx, 32, RULE_inlineTag);
+		int _la;
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(192);
+			match(INLINE_TAG_START);
+			setState(193);
+			inlineTagName();
+			setState(197);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,26,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					{
+					{
+					setState(194);
+					match(SPACE);
+					}
+					} 
+				}
+				setState(199);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,26,_ctx);
+			}
+			setState(201);
+			_la = _input.LA(1);
+			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << NEWLINE) | (1L << SPACE) | (1L << TEXT_CONTENT) | (1L << STAR) | (1L << SLASH) | (1L << BRACE_OPEN))) != 0)) {
+				{
+				setState(200);
+				inlineTagContent();
+				}
+			}
+
+			setState(203);
+			match(BRACE_CLOSE);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InlineTagNameContext extends ParserRuleContext {
+		public TerminalNode NAME() { return getToken(JavadocParser.NAME, 0); }
+		public InlineTagNameContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_inlineTagName; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInlineTagName(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInlineTagName(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInlineTagName(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final InlineTagNameContext inlineTagName() throws RecognitionException {
+		InlineTagNameContext _localctx = new InlineTagNameContext(_ctx, getState());
+		enterRule(_localctx, 34, RULE_inlineTagName);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(205);
+			match(NAME);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class InlineTagContentContext extends ParserRuleContext {
+		public List<BraceContentContext> braceContent() {
+			return getRuleContexts(BraceContentContext.class);
+		}
+		public BraceContentContext braceContent(int i) {
+			return getRuleContext(BraceContentContext.class,i);
+		}
+		public InlineTagContentContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_inlineTagContent; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInlineTagContent(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInlineTagContent(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInlineTagContent(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final InlineTagContentContext inlineTagContent() throws RecognitionException {
+		InlineTagContentContext _localctx = new InlineTagContentContext(_ctx, getState());
+		enterRule(_localctx, 36, RULE_inlineTagContent);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(208); 
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			do {
+				{
+				{
+				setState(207);
+				braceContent();
+				}
+				}
+				setState(210); 
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << NEWLINE) | (1L << SPACE) | (1L << TEXT_CONTENT) | (1L << STAR) | (1L << SLASH) | (1L << BRACE_OPEN))) != 0) );
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class BraceExpressionContext extends ParserRuleContext {
+		public TerminalNode BRACE_OPEN() { return getToken(JavadocParser.BRACE_OPEN, 0); }
+		public TerminalNode BRACE_CLOSE() { return getToken(JavadocParser.BRACE_CLOSE, 0); }
+		public List<BraceContentContext> braceContent() {
+			return getRuleContexts(BraceContentContext.class);
+		}
+		public BraceContentContext braceContent(int i) {
+			return getRuleContext(BraceContentContext.class,i);
+		}
+		public BraceExpressionContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_braceExpression; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBraceExpression(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBraceExpression(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBraceExpression(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final BraceExpressionContext braceExpression() throws RecognitionException {
+		BraceExpressionContext _localctx = new BraceExpressionContext(_ctx, getState());
+		enterRule(_localctx, 38, RULE_braceExpression);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(212);
+			match(BRACE_OPEN);
+			setState(216);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << NEWLINE) | (1L << SPACE) | (1L << TEXT_CONTENT) | (1L << STAR) | (1L << SLASH) | (1L << BRACE_OPEN))) != 0)) {
+				{
+				{
+				setState(213);
+				braceContent();
+				}
+				}
+				setState(218);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			setState(219);
+			match(BRACE_CLOSE);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class BraceContentContext extends ParserRuleContext {
+		public BraceExpressionContext braceExpression() {
+			return getRuleContext(BraceExpressionContext.class,0);
+		}
+		public List<BraceTextContext> braceText() {
+			return getRuleContexts(BraceTextContext.class);
+		}
+		public BraceTextContext braceText(int i) {
+			return getRuleContext(BraceTextContext.class,i);
+		}
+		public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); }
+		public TerminalNode NEWLINE(int i) {
+			return getToken(JavadocParser.NEWLINE, i);
+		}
+		public BraceContentContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_braceContent; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBraceContent(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBraceContent(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBraceContent(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final BraceContentContext braceContent() throws RecognitionException {
+		BraceContentContext _localctx = new BraceContentContext(_ctx, getState());
+		enterRule(_localctx, 40, RULE_braceContent);
+		try {
+			int _alt;
+			setState(235);
+			switch (_input.LA(1)) {
+			case BRACE_OPEN:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(221);
+				braceExpression();
+				}
+				break;
+			case NAME:
+			case NEWLINE:
+			case SPACE:
+			case TEXT_CONTENT:
+			case STAR:
+			case SLASH:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(222);
+				braceText();
+				setState(232);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
+				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+					if ( _alt==1 ) {
+						{
+						{
+						setState(226);
+						_errHandler.sync(this);
+						_alt = getInterpreter().adaptivePredict(_input,30,_ctx);
+						while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+							if ( _alt==1 ) {
+								{
+								{
+								setState(223);
+								match(NEWLINE);
+								}
+								} 
+							}
+							setState(228);
+							_errHandler.sync(this);
+							_alt = getInterpreter().adaptivePredict(_input,30,_ctx);
+						}
+						setState(229);
+						braceText();
+						}
+						} 
+					}
+					setState(234);
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
+				}
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class BraceTextContext extends ParserRuleContext {
+		public TerminalNode TEXT_CONTENT() { return getToken(JavadocParser.TEXT_CONTENT, 0); }
+		public TerminalNode NAME() { return getToken(JavadocParser.NAME, 0); }
+		public TerminalNode SPACE() { return getToken(JavadocParser.SPACE, 0); }
+		public TerminalNode STAR() { return getToken(JavadocParser.STAR, 0); }
+		public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); }
+		public TerminalNode NEWLINE() { return getToken(JavadocParser.NEWLINE, 0); }
+		public BraceTextContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_braceText; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBraceText(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBraceText(this);
+		}
+		@Override
+		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+			if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBraceText(this);
+			else return visitor.visitChildren(this);
+		}
+	}
+
+	public final BraceTextContext braceText() throws RecognitionException {
+		BraceTextContext _localctx = new BraceTextContext(_ctx, getState());
+		enterRule(_localctx, 42, RULE_braceText);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(237);
+			_la = _input.LA(1);
+			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << NEWLINE) | (1L << SPACE) | (1L << TEXT_CONTENT) | (1L << STAR) | (1L << SLASH))) != 0)) ) {
+			_errHandler.recoverInline(this);
+			} else {
+				consume();
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static final String _serializedATN =
+		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\16\u00f2\4\2\t\2"+
+		"\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
+		"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
+		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\3\2\3\2\3\2\7\2\62"+
+		"\n\2\f\2\16\2\65\13\2\3\2\3\2\3\2\3\2\3\2\7\2<\n\2\f\2\16\2?\13\2\3\2"+
+		"\3\2\3\2\5\2D\n\2\3\3\3\3\7\3H\n\3\f\3\16\3K\13\3\3\3\7\3N\n\3\f\3\16"+
+		"\3Q\13\3\3\3\3\3\3\3\6\3V\n\3\r\3\16\3W\3\3\7\3[\n\3\f\3\16\3^\13\3\3"+
+		"\3\3\3\5\3b\n\3\3\4\3\4\3\5\3\5\6\5h\n\5\r\5\16\5i\3\5\3\5\7\5n\n\5\f"+
+		"\5\16\5q\13\5\3\6\3\6\7\6u\n\6\f\6\16\6x\13\6\3\6\3\6\7\6|\n\6\f\6\16"+
+		"\6\177\13\6\5\6\u0081\n\6\3\7\5\7\u0084\n\7\3\7\6\7\u0087\n\7\r\7\16\7"+
+		"\u0088\3\7\3\7\3\7\7\7\u008e\n\7\f\7\16\7\u0091\13\7\3\b\3\b\3\t\3\t\5"+
+		"\t\u0097\n\t\3\n\3\n\3\n\6\n\u009c\n\n\r\n\16\n\u009d\3\13\3\13\3\f\6"+
+		"\f\u00a3\n\f\r\f\16\f\u00a4\3\r\5\r\u00a8\n\r\3\r\3\r\3\r\5\r\u00ad\n"+
+		"\r\3\r\7\r\u00b0\n\r\f\r\16\r\u00b3\13\r\3\16\3\16\3\17\3\17\3\17\5\17"+
+		"\u00ba\n\17\3\20\6\20\u00bd\n\20\r\20\16\20\u00be\3\21\3\21\3\22\3\22"+
+		"\3\22\7\22\u00c6\n\22\f\22\16\22\u00c9\13\22\3\22\5\22\u00cc\n\22\3\22"+
+		"\3\22\3\23\3\23\3\24\6\24\u00d3\n\24\r\24\16\24\u00d4\3\25\3\25\7\25\u00d9"+
+		"\n\25\f\25\16\25\u00dc\13\25\3\25\3\25\3\26\3\26\3\26\7\26\u00e3\n\26"+
+		"\f\26\16\26\u00e6\13\26\3\26\7\26\u00e9\n\26\f\26\16\26\u00ec\13\26\5"+
+		"\26\u00ee\n\26\3\27\3\27\3\27\2\2\30\2\4\6\b\n\f\16\20\22\24\26\30\32"+
+		"\34\36 \"$&(*,\2\6\3\2\4\5\6\2\3\3\6\6\b\t\r\16\6\2\3\3\5\6\b\t\r\16\4"+
+		"\2\3\6\b\t\u0101\2C\3\2\2\2\4a\3\2\2\2\6c\3\2\2\2\be\3\2\2\2\n\u0080\3"+
+		"\2\2\2\f\u0083\3\2\2\2\16\u0092\3\2\2\2\20\u0096\3\2\2\2\22\u009b\3\2"+
+		"\2\2\24\u009f\3\2\2\2\26\u00a2\3\2\2\2\30\u00a7\3\2\2\2\32\u00b4\3\2\2"+
+		"\2\34\u00b9\3\2\2\2\36\u00bc\3\2\2\2 \u00c0\3\2\2\2\"\u00c2\3\2\2\2$\u00cf"+
+		"\3\2\2\2&\u00d2\3\2\2\2(\u00d6\3\2\2\2*\u00ed\3\2\2\2,\u00ef\3\2\2\2."+
+		"D\7\2\2\3/\63\7\n\2\2\60\62\5\6\4\2\61\60\3\2\2\2\62\65\3\2\2\2\63\61"+
+		"\3\2\2\2\63\64\3\2\2\2\64\66\3\2\2\2\65\63\3\2\2\2\66\67\5\4\3\2\678\7"+
+		"\13\2\289\7\2\2\39D\3\2\2\2:<\5\6\4\2;:\3\2\2\2<?\3\2\2\2=;\3\2\2\2=>"+
+		"\3\2\2\2>@\3\2\2\2?=\3\2\2\2@A\5\4\3\2AB\7\2\2\3BD\3\2\2\2C.\3\2\2\2C"+
+		"/\3\2\2\2C=\3\2\2\2D\3\3\2\2\2EI\5\b\5\2FH\5\6\4\2GF\3\2\2\2HK\3\2\2\2"+
+		"IG\3\2\2\2IJ\3\2\2\2Jb\3\2\2\2KI\3\2\2\2LN\5\6\4\2ML\3\2\2\2NQ\3\2\2\2"+
+		"OM\3\2\2\2OP\3\2\2\2PR\3\2\2\2QO\3\2\2\2Rb\5\26\f\2SU\5\b\5\2TV\7\4\2"+
+		"\2UT\3\2\2\2VW\3\2\2\2WU\3\2\2\2WX\3\2\2\2X\\\3\2\2\2Y[\5\6\4\2ZY\3\2"+
+		"\2\2[^\3\2\2\2\\Z\3\2\2\2\\]\3\2\2\2]_\3\2\2\2^\\\3\2\2\2_`\5\26\f\2`"+
+		"b\3\2\2\2aE\3\2\2\2aO\3\2\2\2aS\3\2\2\2b\5\3\2\2\2cd\t\2\2\2d\7\3\2\2"+
+		"\2eo\5\n\6\2fh\5\24\13\2gf\3\2\2\2hi\3\2\2\2ig\3\2\2\2ij\3\2\2\2jk\3\2"+
+		"\2\2kl\5\n\6\2ln\3\2\2\2mg\3\2\2\2nq\3\2\2\2om\3\2\2\2op\3\2\2\2p\t\3"+
+		"\2\2\2qo\3\2\2\2rv\5\f\7\2su\5\20\t\2ts\3\2\2\2ux\3\2\2\2vt\3\2\2\2vw"+
+		"\3\2\2\2w\u0081\3\2\2\2xv\3\2\2\2y}\5\"\22\2z|\5\20\t\2{z\3\2\2\2|\177"+
+		"\3\2\2\2}{\3\2\2\2}~\3\2\2\2~\u0081\3\2\2\2\177}\3\2\2\2\u0080r\3\2\2"+
+		"\2\u0080y\3\2\2\2\u0081\13\3\2\2\2\u0082\u0084\7\5\2\2\u0083\u0082\3\2"+
+		"\2\2\u0083\u0084\3\2\2\2\u0084\u0086\3\2\2\2\u0085\u0087\5\16\b\2\u0086"+
+		"\u0085\3\2\2\2\u0087\u0088\3\2\2\2\u0088\u0086\3\2\2\2\u0088\u0089\3\2"+
+		"\2\2\u0089\u008f\3\2\2\2\u008a\u008e\5\16\b\2\u008b\u008e\7\5\2\2\u008c"+
+		"\u008e\7\7\2\2\u008d\u008a\3\2\2\2\u008d\u008b\3\2\2\2\u008d\u008c\3\2"+
+		"\2\2\u008e\u0091\3\2\2\2\u008f\u008d\3\2\2\2\u008f\u0090\3\2\2\2\u0090"+
+		"\r\3\2\2\2\u0091\u008f\3\2\2\2\u0092\u0093\t\3\2\2\u0093\17\3\2\2\2\u0094"+
+		"\u0097\5\"\22\2\u0095\u0097\5\22\n\2\u0096\u0094\3\2\2\2\u0096\u0095\3"+
+		"\2\2\2\u0097\21\3\2\2\2\u0098\u009c\5\16\b\2\u0099\u009c\7\5\2\2\u009a"+
+		"\u009c\7\7\2\2\u009b\u0098\3\2\2\2\u009b\u0099\3\2\2\2\u009b\u009a\3\2"+
+		"\2\2\u009c\u009d\3\2\2\2\u009d\u009b\3\2\2\2\u009d\u009e\3\2\2\2\u009e"+
+		"\23\3\2\2\2\u009f\u00a0\7\4\2\2\u00a0\25\3\2\2\2\u00a1\u00a3\5\30\r\2"+
+		"\u00a2\u00a1\3\2\2\2\u00a3\u00a4\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a4\u00a5"+
+		"\3\2\2\2\u00a5\27\3\2\2\2\u00a6\u00a8\7\5\2\2\u00a7\u00a6\3\2\2\2\u00a7"+
+		"\u00a8\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00aa\7\7\2\2\u00aa\u00ac\5\32"+
+		"\16\2\u00ab\u00ad\7\5\2\2\u00ac\u00ab\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad"+
+		"\u00b1\3\2\2\2\u00ae\u00b0\5\34\17\2\u00af\u00ae\3\2\2\2\u00b0\u00b3\3"+
+		"\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\31\3\2\2\2\u00b3"+
+		"\u00b1\3\2\2\2\u00b4\u00b5\7\3\2\2\u00b5\33\3\2\2\2\u00b6\u00ba\5\36\20"+
+		"\2\u00b7\u00ba\5\"\22\2\u00b8\u00ba\7\4\2\2\u00b9\u00b6\3\2\2\2\u00b9"+
+		"\u00b7\3\2\2\2\u00b9\u00b8\3\2\2\2\u00ba\35\3\2\2\2\u00bb\u00bd\5 \21"+
+		"\2\u00bc\u00bb\3\2\2\2\u00bd\u00be\3\2\2\2\u00be\u00bc\3\2\2\2\u00be\u00bf"+
+		"\3\2\2\2\u00bf\37\3\2\2\2\u00c0\u00c1\t\4\2\2\u00c1!\3\2\2\2\u00c2\u00c3"+
+		"\7\f\2\2\u00c3\u00c7\5$\23\2\u00c4\u00c6\7\5\2\2\u00c5\u00c4\3\2\2\2\u00c6"+
+		"\u00c9\3\2\2\2\u00c7\u00c5\3\2\2\2\u00c7\u00c8\3\2\2\2\u00c8\u00cb\3\2"+
+		"\2\2\u00c9\u00c7\3\2\2\2\u00ca\u00cc\5&\24\2\u00cb\u00ca\3\2\2\2\u00cb"+
+		"\u00cc\3\2\2\2\u00cc\u00cd\3\2\2\2\u00cd\u00ce\7\16\2\2\u00ce#\3\2\2\2"+
+		"\u00cf\u00d0\7\3\2\2\u00d0%\3\2\2\2\u00d1\u00d3\5*\26\2\u00d2\u00d1\3"+
+		"\2\2\2\u00d3\u00d4\3\2\2\2\u00d4\u00d2\3\2\2\2\u00d4\u00d5\3\2\2\2\u00d5"+
+		"\'\3\2\2\2\u00d6\u00da\7\r\2\2\u00d7\u00d9\5*\26\2\u00d8\u00d7\3\2\2\2"+
+		"\u00d9\u00dc\3\2\2\2\u00da\u00d8\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00dd"+
+		"\3\2\2\2\u00dc\u00da\3\2\2\2\u00dd\u00de\7\16\2\2\u00de)\3\2\2\2\u00df"+
+		"\u00ee\5(\25\2\u00e0\u00ea\5,\27\2\u00e1\u00e3\7\4\2\2\u00e2\u00e1\3\2"+
+		"\2\2\u00e3\u00e6\3\2\2\2\u00e4\u00e2\3\2\2\2\u00e4\u00e5\3\2\2\2\u00e5"+
+		"\u00e7\3\2\2\2\u00e6\u00e4\3\2\2\2\u00e7\u00e9\5,\27\2\u00e8\u00e4\3\2"+
+		"\2\2\u00e9\u00ec\3\2\2\2\u00ea\u00e8\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb"+
+		"\u00ee\3\2\2\2\u00ec\u00ea\3\2\2\2\u00ed\u00df\3\2\2\2\u00ed\u00e0\3\2"+
+		"\2\2\u00ee+\3\2\2\2\u00ef\u00f0\t\5\2\2\u00f0-\3\2\2\2#\63=CIOW\\aiov"+
+		"}\u0080\u0083\u0088\u008d\u008f\u0096\u009b\u009d\u00a4\u00a7\u00ac\u00b1"+
+		"\u00b9\u00be\u00c7\u00cb\u00d4\u00da\u00e4\u00ea\u00ed";
+	public static final ATN _ATN =
+		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
+	static {
+		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
+		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
+			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParser.tokens b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParser.tokens
new file mode 100644
index 0000000..39ad57e
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParser.tokens
@@ -0,0 +1,18 @@
+NAME=1
+NEWLINE=2
+SPACE=3
+TEXT_CONTENT=4
+AT=5
+STAR=6
+SLASH=7
+JAVADOC_START=8
+JAVADOC_END=9
+INLINE_TAG_START=10
+BRACE_OPEN=11
+BRACE_CLOSE=12
+'@'=5
+'*'=6
+'/'=7
+'{@'=10
+'{'=11
+'}'=12
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserBaseListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserBaseListener.java
new file mode 100644
index 0000000..32e271a
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserBaseListener.java
@@ -0,0 +1,303 @@
+// Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\JavadocParser.g4 by ANTLR 4.5.1
+package ru.ftc.upc.testing.dropper.lang.gen;
+
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.tree.ErrorNode;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+/**
+ * This class provides an empty implementation of {@link JavadocParserListener},
+ * which can be extended to create a listener which only needs to handle a subset
+ * of the available methods.
+ */
+public class JavadocParserBaseListener implements JavadocParserListener {
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterDocumentation(JavadocParser.DocumentationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitDocumentation(JavadocParser.DocumentationContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterDocumentationContent(JavadocParser.DocumentationContentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitDocumentationContent(JavadocParser.DocumentationContentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterSkipWhitespace(JavadocParser.SkipWhitespaceContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitSkipWhitespace(JavadocParser.SkipWhitespaceContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterDescription(JavadocParser.DescriptionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitDescription(JavadocParser.DescriptionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterDescriptionLine(JavadocParser.DescriptionLineContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitDescriptionLine(JavadocParser.DescriptionLineContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterDescriptionLineStart(JavadocParser.DescriptionLineStartContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitDescriptionLineStart(JavadocParser.DescriptionLineStartContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterDescriptionLineNoSpaceNoAt(JavadocParser.DescriptionLineNoSpaceNoAtContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitDescriptionLineNoSpaceNoAt(JavadocParser.DescriptionLineNoSpaceNoAtContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterDescriptionLineElement(JavadocParser.DescriptionLineElementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitDescriptionLineElement(JavadocParser.DescriptionLineElementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterDescriptionLineText(JavadocParser.DescriptionLineTextContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitDescriptionLineText(JavadocParser.DescriptionLineTextContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterDescriptionNewline(JavadocParser.DescriptionNewlineContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitDescriptionNewline(JavadocParser.DescriptionNewlineContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTagSection(JavadocParser.TagSectionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTagSection(JavadocParser.TagSectionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterBlockTag(JavadocParser.BlockTagContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitBlockTag(JavadocParser.BlockTagContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterBlockTagName(JavadocParser.BlockTagNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitBlockTagName(JavadocParser.BlockTagNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterBlockTagContent(JavadocParser.BlockTagContentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitBlockTagContent(JavadocParser.BlockTagContentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterBlockTagText(JavadocParser.BlockTagTextContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitBlockTagText(JavadocParser.BlockTagTextContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterBlockTagTextElement(JavadocParser.BlockTagTextElementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitBlockTagTextElement(JavadocParser.BlockTagTextElementContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInlineTag(JavadocParser.InlineTagContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInlineTag(JavadocParser.InlineTagContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInlineTagName(JavadocParser.InlineTagNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInlineTagName(JavadocParser.InlineTagNameContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterInlineTagContent(JavadocParser.InlineTagContentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitInlineTagContent(JavadocParser.InlineTagContentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterBraceExpression(JavadocParser.BraceExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitBraceExpression(JavadocParser.BraceExpressionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterBraceContent(JavadocParser.BraceContentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitBraceContent(JavadocParser.BraceContentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterBraceText(JavadocParser.BraceTextContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitBraceText(JavadocParser.BraceTextContext ctx) { }
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterEveryRule(ParserRuleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitEveryRule(ParserRuleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void visitTerminal(TerminalNode node) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void visitErrorNode(ErrorNode node) { }
+}
\ No newline at end of file
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserBaseVisitor.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserBaseVisitor.java
new file mode 100644
index 0000000..431a34f
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserBaseVisitor.java
@@ -0,0 +1,168 @@
+// Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\JavadocParser.g4 by ANTLR 4.5.1
+package ru.ftc.upc.testing.dropper.lang.gen;
+import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
+
+/**
+ * This class provides an empty implementation of {@link JavadocParserVisitor},
+ * which can be extended to create a visitor which only needs to handle a subset
+ * of the available methods.
+ *
+ * @param <T> The return type of the visit operation. Use {@link Void} for
+ * operations with no return type.
+ */
+public class JavadocParserBaseVisitor<T> extends AbstractParseTreeVisitor<T> implements JavadocParserVisitor<T> {
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitDocumentation(JavadocParser.DocumentationContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitDocumentationContent(JavadocParser.DocumentationContentContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitSkipWhitespace(JavadocParser.SkipWhitespaceContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitDescription(JavadocParser.DescriptionContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitDescriptionLine(JavadocParser.DescriptionLineContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitDescriptionLineStart(JavadocParser.DescriptionLineStartContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitDescriptionLineNoSpaceNoAt(JavadocParser.DescriptionLineNoSpaceNoAtContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitDescriptionLineElement(JavadocParser.DescriptionLineElementContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitDescriptionLineText(JavadocParser.DescriptionLineTextContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitDescriptionNewline(JavadocParser.DescriptionNewlineContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitTagSection(JavadocParser.TagSectionContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitBlockTag(JavadocParser.BlockTagContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitBlockTagName(JavadocParser.BlockTagNameContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitBlockTagContent(JavadocParser.BlockTagContentContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitBlockTagText(JavadocParser.BlockTagTextContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitBlockTagTextElement(JavadocParser.BlockTagTextElementContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitInlineTag(JavadocParser.InlineTagContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitInlineTagName(JavadocParser.InlineTagNameContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitInlineTagContent(JavadocParser.InlineTagContentContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitBraceExpression(JavadocParser.BraceExpressionContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitBraceContent(JavadocParser.BraceContentContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitBraceText(JavadocParser.BraceTextContext ctx) { return visitChildren(ctx); }
+}
\ No newline at end of file
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserListener.java
new file mode 100644
index 0000000..66655ab
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserListener.java
@@ -0,0 +1,230 @@
+// Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\JavadocParser.g4 by ANTLR 4.5.1
+package ru.ftc.upc.testing.dropper.lang.gen;
+import org.antlr.v4.runtime.tree.ParseTreeListener;
+
+/**
+ * This interface defines a complete listener for a parse tree produced by
+ * {@link JavadocParser}.
+ */
+public interface JavadocParserListener extends ParseTreeListener {
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#documentation}.
+	 * @param ctx the parse tree
+	 */
+	void enterDocumentation(JavadocParser.DocumentationContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#documentation}.
+	 * @param ctx the parse tree
+	 */
+	void exitDocumentation(JavadocParser.DocumentationContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#documentationContent}.
+	 * @param ctx the parse tree
+	 */
+	void enterDocumentationContent(JavadocParser.DocumentationContentContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#documentationContent}.
+	 * @param ctx the parse tree
+	 */
+	void exitDocumentationContent(JavadocParser.DocumentationContentContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#skipWhitespace}.
+	 * @param ctx the parse tree
+	 */
+	void enterSkipWhitespace(JavadocParser.SkipWhitespaceContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#skipWhitespace}.
+	 * @param ctx the parse tree
+	 */
+	void exitSkipWhitespace(JavadocParser.SkipWhitespaceContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#description}.
+	 * @param ctx the parse tree
+	 */
+	void enterDescription(JavadocParser.DescriptionContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#description}.
+	 * @param ctx the parse tree
+	 */
+	void exitDescription(JavadocParser.DescriptionContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#descriptionLine}.
+	 * @param ctx the parse tree
+	 */
+	void enterDescriptionLine(JavadocParser.DescriptionLineContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#descriptionLine}.
+	 * @param ctx the parse tree
+	 */
+	void exitDescriptionLine(JavadocParser.DescriptionLineContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#descriptionLineStart}.
+	 * @param ctx the parse tree
+	 */
+	void enterDescriptionLineStart(JavadocParser.DescriptionLineStartContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#descriptionLineStart}.
+	 * @param ctx the parse tree
+	 */
+	void exitDescriptionLineStart(JavadocParser.DescriptionLineStartContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#descriptionLineNoSpaceNoAt}.
+	 * @param ctx the parse tree
+	 */
+	void enterDescriptionLineNoSpaceNoAt(JavadocParser.DescriptionLineNoSpaceNoAtContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#descriptionLineNoSpaceNoAt}.
+	 * @param ctx the parse tree
+	 */
+	void exitDescriptionLineNoSpaceNoAt(JavadocParser.DescriptionLineNoSpaceNoAtContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#descriptionLineElement}.
+	 * @param ctx the parse tree
+	 */
+	void enterDescriptionLineElement(JavadocParser.DescriptionLineElementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#descriptionLineElement}.
+	 * @param ctx the parse tree
+	 */
+	void exitDescriptionLineElement(JavadocParser.DescriptionLineElementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#descriptionLineText}.
+	 * @param ctx the parse tree
+	 */
+	void enterDescriptionLineText(JavadocParser.DescriptionLineTextContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#descriptionLineText}.
+	 * @param ctx the parse tree
+	 */
+	void exitDescriptionLineText(JavadocParser.DescriptionLineTextContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#descriptionNewline}.
+	 * @param ctx the parse tree
+	 */
+	void enterDescriptionNewline(JavadocParser.DescriptionNewlineContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#descriptionNewline}.
+	 * @param ctx the parse tree
+	 */
+	void exitDescriptionNewline(JavadocParser.DescriptionNewlineContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#tagSection}.
+	 * @param ctx the parse tree
+	 */
+	void enterTagSection(JavadocParser.TagSectionContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#tagSection}.
+	 * @param ctx the parse tree
+	 */
+	void exitTagSection(JavadocParser.TagSectionContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#blockTag}.
+	 * @param ctx the parse tree
+	 */
+	void enterBlockTag(JavadocParser.BlockTagContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#blockTag}.
+	 * @param ctx the parse tree
+	 */
+	void exitBlockTag(JavadocParser.BlockTagContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#blockTagName}.
+	 * @param ctx the parse tree
+	 */
+	void enterBlockTagName(JavadocParser.BlockTagNameContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#blockTagName}.
+	 * @param ctx the parse tree
+	 */
+	void exitBlockTagName(JavadocParser.BlockTagNameContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#blockTagContent}.
+	 * @param ctx the parse tree
+	 */
+	void enterBlockTagContent(JavadocParser.BlockTagContentContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#blockTagContent}.
+	 * @param ctx the parse tree
+	 */
+	void exitBlockTagContent(JavadocParser.BlockTagContentContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#blockTagText}.
+	 * @param ctx the parse tree
+	 */
+	void enterBlockTagText(JavadocParser.BlockTagTextContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#blockTagText}.
+	 * @param ctx the parse tree
+	 */
+	void exitBlockTagText(JavadocParser.BlockTagTextContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#blockTagTextElement}.
+	 * @param ctx the parse tree
+	 */
+	void enterBlockTagTextElement(JavadocParser.BlockTagTextElementContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#blockTagTextElement}.
+	 * @param ctx the parse tree
+	 */
+	void exitBlockTagTextElement(JavadocParser.BlockTagTextElementContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#inlineTag}.
+	 * @param ctx the parse tree
+	 */
+	void enterInlineTag(JavadocParser.InlineTagContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#inlineTag}.
+	 * @param ctx the parse tree
+	 */
+	void exitInlineTag(JavadocParser.InlineTagContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#inlineTagName}.
+	 * @param ctx the parse tree
+	 */
+	void enterInlineTagName(JavadocParser.InlineTagNameContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#inlineTagName}.
+	 * @param ctx the parse tree
+	 */
+	void exitInlineTagName(JavadocParser.InlineTagNameContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#inlineTagContent}.
+	 * @param ctx the parse tree
+	 */
+	void enterInlineTagContent(JavadocParser.InlineTagContentContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#inlineTagContent}.
+	 * @param ctx the parse tree
+	 */
+	void exitInlineTagContent(JavadocParser.InlineTagContentContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#braceExpression}.
+	 * @param ctx the parse tree
+	 */
+	void enterBraceExpression(JavadocParser.BraceExpressionContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#braceExpression}.
+	 * @param ctx the parse tree
+	 */
+	void exitBraceExpression(JavadocParser.BraceExpressionContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#braceContent}.
+	 * @param ctx the parse tree
+	 */
+	void enterBraceContent(JavadocParser.BraceContentContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#braceContent}.
+	 * @param ctx the parse tree
+	 */
+	void exitBraceContent(JavadocParser.BraceContentContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link JavadocParser#braceText}.
+	 * @param ctx the parse tree
+	 */
+	void enterBraceText(JavadocParser.BraceTextContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link JavadocParser#braceText}.
+	 * @param ctx the parse tree
+	 */
+	void exitBraceText(JavadocParser.BraceTextContext ctx);
+}
\ No newline at end of file
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserVisitor.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserVisitor.java
new file mode 100644
index 0000000..e848b56
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserVisitor.java
@@ -0,0 +1,145 @@
+// Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\JavadocParser.g4 by ANTLR 4.5.1
+package ru.ftc.upc.testing.dropper.lang.gen;
+import org.antlr.v4.runtime.tree.ParseTreeVisitor;
+
+/**
+ * This interface defines a complete generic visitor for a parse tree produced
+ * by {@link JavadocParser}.
+ *
+ * @param <T> The return type of the visit operation. Use {@link Void} for
+ * operations with no return type.
+ */
+public interface JavadocParserVisitor<T> extends ParseTreeVisitor<T> {
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#documentation}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitDocumentation(JavadocParser.DocumentationContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#documentationContent}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitDocumentationContent(JavadocParser.DocumentationContentContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#skipWhitespace}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitSkipWhitespace(JavadocParser.SkipWhitespaceContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#description}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitDescription(JavadocParser.DescriptionContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#descriptionLine}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitDescriptionLine(JavadocParser.DescriptionLineContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#descriptionLineStart}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitDescriptionLineStart(JavadocParser.DescriptionLineStartContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#descriptionLineNoSpaceNoAt}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitDescriptionLineNoSpaceNoAt(JavadocParser.DescriptionLineNoSpaceNoAtContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#descriptionLineElement}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitDescriptionLineElement(JavadocParser.DescriptionLineElementContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#descriptionLineText}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitDescriptionLineText(JavadocParser.DescriptionLineTextContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#descriptionNewline}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitDescriptionNewline(JavadocParser.DescriptionNewlineContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#tagSection}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitTagSection(JavadocParser.TagSectionContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#blockTag}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitBlockTag(JavadocParser.BlockTagContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#blockTagName}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitBlockTagName(JavadocParser.BlockTagNameContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#blockTagContent}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitBlockTagContent(JavadocParser.BlockTagContentContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#blockTagText}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitBlockTagText(JavadocParser.BlockTagTextContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#blockTagTextElement}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitBlockTagTextElement(JavadocParser.BlockTagTextElementContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#inlineTag}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitInlineTag(JavadocParser.InlineTagContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#inlineTagName}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitInlineTagName(JavadocParser.InlineTagNameContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#inlineTagContent}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitInlineTagContent(JavadocParser.InlineTagContentContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#braceExpression}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitBraceExpression(JavadocParser.BraceExpressionContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#braceContent}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitBraceContent(JavadocParser.BraceContentContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link JavadocParser#braceText}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitBraceText(JavadocParser.BraceTextContext ctx);
+}
\ No newline at end of file
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/TargetsMap.java b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java
similarity index 90%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/TargetsMap.java
rename to src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java
index d551d3c..2747b2c 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/TargetsMap.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java
@@ -1,6 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang;
-
-import ru.ftc.upc.testing.dropper.model.TargetMethod;
+package ru.ftc.upc.testing.dropper.model;
 
 import java.util.Deque;
 import java.util.LinkedList;
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/CutpointAssemblerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/CutpointAssemblerTest.java
new file mode 100644
index 0000000..8c73f25
--- /dev/null
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/CutpointAssemblerTest.java
@@ -0,0 +1,81 @@
+package ru.ftc.upc.testing.dropper.lang;
+
+import org.antlr.v4.runtime.ANTLRFileStream;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.TokenStream;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+import org.junit.Test;
+import ru.ftc.upc.testing.dropper.Cutpoint;
+import ru.ftc.upc.testing.dropper.lang.gen.JavadocLexer;
+import ru.ftc.upc.testing.dropper.lang.gen.JavadocParser;
+
+import java.io.IOException;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+/**
+ * @author Toparvion
+ */
+public class CutpointAssemblerTest {
+
+  @Test
+  public void cutpoint1IsRecognizedCorrectly() throws Exception {
+    CutpointAssembler cutpointAssembler = loadJavadoc("src/test/resources/Cutpoint_1.javadoc");
+    String tagValue = cutpointAssembler.getTagValue();
+    Cutpoint cutpoint = Cutpoint.valueOf(tagValue.toUpperCase());
+    System.out.printf("Cutpoint 1: '%s'\n", tagValue);
+    assertEquals(Cutpoint.BEFORE, cutpoint);
+  }
+
+  @Test
+  public void cutpoint2IsRecognizedCorrectly() throws Exception {
+    CutpointAssembler cutpointAssembler = loadJavadoc("src/test/resources/Cutpoint_2.javadoc");
+    String tagValue = cutpointAssembler.getTagValue();
+    Cutpoint cutpoint = Cutpoint.valueOf(tagValue.toUpperCase());
+    System.out.printf("Cutpoint 2: '%s'\n", tagValue);
+    assertEquals(Cutpoint.CATCH, cutpoint);
+  }
+
+  @Test
+  public void cutpoint3IsRecognizedCorrectly() throws Exception {
+    CutpointAssembler cutpointAssembler = loadJavadoc("src/test/resources/Cutpoint_3.javadoc");
+    String tagValue = cutpointAssembler.getTagValue();
+    Cutpoint cutpoint = Cutpoint.valueOf(tagValue.toUpperCase());
+    System.out.printf("Cutpoint 3: '%s'\n", tagValue);
+    assertEquals(Cutpoint.INSTEAD, cutpoint);
+  }
+
+  @Test
+  public void cutpoint4IsRecognizedCorrectly() throws Exception {
+    CutpointAssembler cutpointAssembler = loadJavadoc("src/test/resources/Cutpoint_4.javadoc");
+    String tagValue = cutpointAssembler.getTagValue();
+    Cutpoint cutpoint = Cutpoint.valueOf(tagValue.toUpperCase());
+    System.out.printf("Cutpoint 4: '%s'\n", tagValue);
+    assertEquals(Cutpoint.AFTER, cutpoint);
+  }
+
+  @Test
+  public void cutpoint5IsRecognizedCorrectly() throws Exception {
+    CutpointAssembler cutpointAssembler = loadJavadoc("src/test/resources/Cutpoint_5.javadoc");
+    String tagValue = cutpointAssembler.getTagValue();
+    System.out.printf("Cutpoint 5: '%s'\n", tagValue);
+    assertNull(tagValue);
+  }
+
+  private CutpointAssembler loadJavadoc(String javadocPath) throws IOException {
+    ANTLRFileStream fileStream = new ANTLRFileStream(javadocPath);
+    JavadocLexer lexer = new JavadocLexer(fileStream);
+    TokenStream tokenStream = new CommonTokenStream(lexer);
+    JavadocParser parser = new JavadocParser(tokenStream);
+    ParseTree tree = parser.documentation();
+
+    CutpointAssembler assembler = new CutpointAssembler();
+    ParseTreeWalker walker = new ParseTreeWalker();
+    walker.walk(assembler, tree);
+
+    return assembler;
+  }
+
+}
\ No newline at end of file
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
index 4f2f83f..42a6697 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
@@ -8,6 +8,7 @@
 import org.junit.Test;
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaLexer;
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
+import ru.ftc.upc.testing.dropper.model.TargetsMap;
 
 import java.io.IOException;
 import java.util.Map;
diff --git a/src/test/resources/Cutpoint_1.javadoc b/src/test/resources/Cutpoint_1.javadoc
new file mode 100644
index 0000000..f1cfc65
--- /dev/null
+++ b/src/test/resources/Cutpoint_1.javadoc
@@ -0,0 +1,8 @@
+/**
+ * Returns boolean.
+ *
+ * @param b	the boolean
+ * @cutpoint BEFORE
+ * @return the string
+ * @since 1.4
+ */
\ No newline at end of file
diff --git a/src/test/resources/Cutpoint_2.javadoc b/src/test/resources/Cutpoint_2.javadoc
new file mode 100644
index 0000000..ef6e952
--- /dev/null
+++ b/src/test/resources/Cutpoint_2.javadoc
@@ -0,0 +1,8 @@
+/**
+ * Returns boolean.
+ *
+ * @param b	the boolean
+ * @cutpoint CATCH java.lang.Exception some text contained in exception message
+ * @return the string
+ * @since 1.4
+ */
\ No newline at end of file
diff --git a/src/test/resources/Cutpoint_3.javadoc b/src/test/resources/Cutpoint_3.javadoc
new file mode 100644
index 0000000..8824a9a
--- /dev/null
+++ b/src/test/resources/Cutpoint_3.javadoc
@@ -0,0 +1,8 @@
+/**
+ * Returns boolean.
+ *
+ * @param b	the boolean
+ * @cuTPOInt INSTEAD
+ * @return the string
+ * @since 1.4
+ */
\ No newline at end of file
diff --git a/src/test/resources/Cutpoint_4.javadoc b/src/test/resources/Cutpoint_4.javadoc
new file mode 100644
index 0000000..4028cc0
--- /dev/null
+++ b/src/test/resources/Cutpoint_4.javadoc
@@ -0,0 +1,8 @@
+/**
+ * Returns boolean.
+ *
+ * @param b	the boolean
+ * @cutpoint        AFTER
+ * @return the string
+ * @since 1.4
+ */
\ No newline at end of file
diff --git a/src/test/resources/Cutpoint_5.javadoc b/src/test/resources/Cutpoint_5.javadoc
new file mode 100644
index 0000000..07792b5
--- /dev/null
+++ b/src/test/resources/Cutpoint_5.javadoc
@@ -0,0 +1,8 @@
+/**
+ * Returns boolean.
+ *
+ * @param b	the boolean
+ * @no_cutpoint        AFTER
+ * @return the string
+ * @since 1.4
+ */
\ No newline at end of file

From c5241d5b56e87ac30464ef1ba2d5d8ac46cc9e14 Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Thu, 2 Jun 2016 23:39:07 +0600
Subject: [PATCH 08/22] UPCSEC-0000 Implemented cutpoints recognition

---
 ...Visitor.java => BodyComposingVisitor.java} |   2 +-
 .../dropper/lang/CutpointAssembler.java       |   4 +-
 .../dropper/lang/DropletAssembler.java        | 135 ++++++++++++++----
 .../upc/testing/dropper/lang/DroppingJava.g4  |   6 +-
 .../dropper/lang/gen/DroppingJavaLexer.java   |  22 ++-
 .../testing/dropper/model/TargetMethod.java   |   2 +-
 .../dropper/lang/DropletAssemblerTest.java    | 111 ++++++++------
 7 files changed, 198 insertions(+), 84 deletions(-)
 rename src/main/java/ru/ftc/upc/testing/dropper/lang/{BodyAssembleTreeVisitor.java => BodyComposingVisitor.java} (89%)

diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/BodyAssembleTreeVisitor.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/BodyComposingVisitor.java
similarity index 89%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/BodyAssembleTreeVisitor.java
rename to src/main/java/ru/ftc/upc/testing/dropper/lang/BodyComposingVisitor.java
index 7bf958c..dc29e45 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/BodyAssembleTreeVisitor.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/BodyComposingVisitor.java
@@ -7,7 +7,7 @@
  * A parse tree visitor for assembling all the child terminal node's texts into single string separated with spaces.
  * @author Toparvion
  */
-class BodyAssembleTreeVisitor extends DroppingJavaBaseVisitor<String> {
+class BodyComposingVisitor extends DroppingJavaBaseVisitor<String> {
 
   @Override
   public String visitTerminal(TerminalNode node) {
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/CutpointAssembler.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/CutpointAssembler.java
index 18c0061..0bac268 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/CutpointAssembler.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/CutpointAssembler.java
@@ -8,7 +8,7 @@
 /**
  * @author Toparvion
  */
-public class CutpointAssembler extends JavadocParserBaseListener {
+class CutpointAssembler extends JavadocParserBaseListener {
 
   private static final String CUTPOINT_TAG_NAME = "cutpoint";
 
@@ -31,7 +31,7 @@ public void enterBlockTag(JavadocParser.BlockTagContext ctx) {
     tagValue = tagValueEntries[0];
   }
 
-  public String getTagValue() {
+  String getTagValue() {
     return tagValue;
   }
 }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
index 5b3a340..24ba6a3 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
@@ -1,11 +1,11 @@
 package ru.ftc.upc.testing.dropper.lang;
 
-import org.antlr.v4.runtime.RuleContext;
-import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
 import org.antlr.v4.runtime.tree.TerminalNode;
-import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaBaseListener;
-import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
-import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaVisitor;
+import ru.ftc.upc.testing.dropper.Cutpoint;
+import ru.ftc.upc.testing.dropper.lang.gen.*;
 import ru.ftc.upc.testing.dropper.model.Argument;
 import ru.ftc.upc.testing.dropper.model.TargetMethod;
 import ru.ftc.upc.testing.dropper.model.TargetsMap;
@@ -19,8 +19,8 @@ class DropletAssembler extends DroppingJavaBaseListener {
 
   /**
    * Mapping between simple type names (e.g. "Droplet") and their FQ prefixes (e.g. "ru.ftc.upc.testing.dropper").
-   * The mapping is built from the import statements at the header of compilation unit and does not include any type
-   * import on demand.
+   * The mapping is built upon the import statements at the header of compilation unit and does not include any type
+   * imports on demand.
    */
   private final Map<String, String> importsMap = new LinkedHashMap<String, String>(10);
   /**
@@ -37,7 +37,16 @@ class DropletAssembler extends DroppingJavaBaseListener {
    * Internal data structure aimed to support depth tracking during parse tree traversing.
    */
   private final Deque<String> classNameStack = new LinkedList<String>();
+  /**
+   * A reference to source token stream to access hidden channels.
+   */
+  private final BufferedTokenStream tokenStream;
+
+  DropletAssembler(BufferedTokenStream tokenStream) {
+    this.tokenStream = tokenStream;
+  }
 
+  //region parse tree event listener methods
   @Override
   public void enterPackageDeclaration(DroppingJavaParser.PackageDeclarationContext ctx) {
     StringBuilder sb = new StringBuilder();
@@ -105,17 +114,53 @@ public void enterMethodHeader(DroppingJavaParser.MethodHeaderContext ctx) {
     // it's time to store method parameters, if any
     DroppingJavaParser.FormalParameterListContext anyParams = declarator.formalParameterList();
     storeMethodParams(method, anyParams);
+
+    // and finally let's extract the cutpoint from preceding javadoc comment, if any
+    String cutpointStr = extractCutpointString(ctx);
+    if (cutpointStr != null) {
+      method.setCutpoint(Cutpoint.valueOf(cutpointStr.toUpperCase()));
+    }
   }
 
   @Override
   public void enterBlockStatements(DroppingJavaParser.BlockStatementsContext ctx) {
-    DroppingJavaVisitor<String> visitor = new BodyAssembleTreeVisitor();
+    DroppingJavaVisitor<String> visitor = new BodyComposingVisitor();
 
     String bodyText = visitor.visit(ctx);
     TargetMethod currentMethod = targetsMap.get(composeCurrentKey()).getLast();
     currentMethod.setText(bodyText);
   }
 
+  @Override
+  public void enterSingleTypeImportDeclaration(DroppingJavaParser.SingleTypeImportDeclarationContext ctx) {
+    DroppingJavaParser.TypeNameContext typeName = ctx.typeName();
+    if (typeName.packageOrTypeName() == null) {
+      // in this case there is no profit in mapping a type to its import prefix so that we just ignore it
+      return;
+    }
+    importsMap.put(typeName.Identifier().getText(), typeName.packageOrTypeName().getText());
+  }
+
+  /**
+   * Type imports on demand are not supported in this version because they introduce quite complicated ambiguity. In
+   * order not to mute their existence we prefer to explicitly inform the user about them with the help of exception.
+   */
+  @Override
+  public void enterTypeImportOnDemandDeclaration(DroppingJavaParser.TypeImportOnDemandDeclarationContext ctx) {
+    Token offendingToken = ctx.getToken(DroppingJavaParser.IMPORT, 0).getSymbol();
+    String offendingImportString = String.format("import %s.*;", ctx.packageOrTypeName().getText());
+    throw new DropletFormatException(String.format("Line %d:%d. Type imports on demand are not supported: '%s'. " +
+            "Please replace it with a set of single type imports.",
+            offendingToken.getLine(), offendingToken.getCharPositionInLine(), offendingImportString));
+  }
+  //endregion
+
+  //region auxiliary methods of the assembler
+  /**
+   * Extracts formal parameters types and names and stores them into the given target method.
+   * @param method target method to store extracted parameters into
+   * @param anyParams  parse rule context of formal parameters list; may be {@code null}
+   */
   private void storeMethodParams(TargetMethod method, DroppingJavaParser.FormalParameterListContext anyParams) {
     if (anyParams == null) return;
     String paramType;
@@ -144,31 +189,61 @@ private void storeMethodParams(TargetMethod method, DroppingJavaParser.FormalPar
     }
   }
 
-  @Override
-  public void enterSingleTypeImportDeclaration(DroppingJavaParser.SingleTypeImportDeclarationContext ctx) {
-    DroppingJavaParser.TypeNameContext typeName = ctx.typeName();
-    if (typeName.packageOrTypeName() == null) {
-      // in this case there is no profit in mapping a type to its import prefix so that we just ignore it
-      return;
-    }
-    importsMap.put(typeName.Identifier().getText(), typeName.packageOrTypeName().getText());
+  /**
+   * Finds the latest entry of fully-qualified type name, e.g. {@code Set} from {@code java.util.Set<String>}.
+   * @param typeCtx type rule context to extract the name from
+   * @return simple name of the type (with package and type parameters cleaned off)
+   */
+  private String getPureTypeName(RuleContext typeCtx) {
+    DroppingJavaVisitor<String> visitor = new PureTypeNameComposingVisitor();
+    return visitor.visit(typeCtx);
   }
 
   /**
-   * Type imports on demand are not supported in this version because they introduce quite complicated ambiguity. In
-   * order not to mute their existence we prefer to explicitly inform the user about them with the help of exception.
+   * Tries to extract string representation of cutpoint from the preceding javadoc comment (if any).
+   * @param ctx rule context of the node which the javadoc is relative to
+   * @return string form of cutpoint or {@code null} if it cannot be extracted for any reason
    */
-  @Override
-  public void enterTypeImportOnDemandDeclaration(DroppingJavaParser.TypeImportOnDemandDeclarationContext ctx) {
-    Token offendingToken = ctx.getToken(DroppingJavaParser.IMPORT, 0).getSymbol();
-    String offendingImportString = String.format("import %s.*;", ctx.packageOrTypeName().getText());
-    throw new DropletFormatException(String.format("Line %d:%d. Type imports on demand are not supported: '%s'. " +
-            "Please replace it with a set of single type imports.",
-            offendingToken.getLine(), offendingToken.getCharPositionInLine(), offendingImportString));
+  private String extractCutpointString(ParserRuleContext ctx) {
+    try {
+      /* Javadoc comments are neighbors to classBodyDeclaration, not the methodHeader so we have to find the ancestor.*/
+      ParserRuleContext classBodyDeclaration = ctx
+              .getParent()    // methodDeclaration
+              .getParent()    // classMemberDeclaration
+              .getParent();   // classBodyDeclaration
+      Token startToken = classBodyDeclaration.getStart();
+      int startITokenIndex = startToken.getTokenIndex();
+      // try to find out if there are any comments left to classBodyDeclaration
+      List<Token> hiddenTokens = tokenStream.getHiddenTokensToLeft(startITokenIndex, DroppingJavaLexer.BLOCK_COMMENTS);
+      if (hiddenTokens == null || hiddenTokens.isEmpty())
+        return null;
+      Token hiddenToken = hiddenTokens.get(0);
+      if (hiddenToken == null)
+        return null;
+
+      // now that we've found one, let's recognize it with separate lexer/parser
+      ANTLRInputStream inputStream = new ANTLRInputStream(hiddenToken.getText());
+      JavadocLexer lexer = new JavadocLexer(inputStream);
+      TokenStream tokenStream = new CommonTokenStream(lexer);
+      JavadocParser parser = new JavadocParser(tokenStream);
+      ParseTree tree = parser.documentation();
+
+      // then find the actual needed value with dedicated listener
+      CutpointAssembler assembler = new CutpointAssembler();
+      ParseTreeWalker walker = new ParseTreeWalker();
+      walker.walk(assembler, tree);
+
+      // and return found value (which eventually may be null)
+      return assembler.getTagValue();
+
+    } catch (Exception e) {   // we can't be sure about anything in comments so that we need a defense line
+      System.out.printf("Couldn't extract cutpoint from javadoc comments: '%s'. Falling back to default.", e.getMessage());
+      return null;
+    }
   }
 
   /**
-   * @return a key for targets map (composed basing on current state of the stack)
+   * @return an actual key for targets map (composed basing on current state of the stack)
    */
   private String composeCurrentKey() {
     StringBuilder sb = new StringBuilder(packageDeclaration);
@@ -185,7 +260,9 @@ private String composeCurrentKey() {
 
     return sb.toString();
   }
+  //endregion
 
+  //region getters
   TargetsMap getTargetsMap() {
     return targetsMap;
   }
@@ -193,10 +270,6 @@ TargetsMap getTargetsMap() {
   Map<String, String> getImportsMap() {
     return importsMap;
   }
-
-  private String getPureTypeName(RuleContext typeCtx) {
-    DroppingJavaVisitor<String> visitor = new PureTypeNameComposingVisitor();
-    return visitor.visit(typeCtx);
-  }
+  //endregion
 
 }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4 b/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4
index b64e149..13574ed 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4
@@ -32,8 +32,12 @@
  * A modified (and simplified) Java 8 grammar for ANTLR 4 derived from the Java Language Specification
  * chapter 19.
  */
+
 grammar DroppingJava;
 
+@lexer::members {
+    public static final int BLOCK_COMMENTS = 2;
+}
 /*
  * Productions from §4 (Types, Values, and Variables)
  */
@@ -1076,7 +1080,7 @@ WS  :  [ \t\r\n\u000C]+ -> skip
     ;
 
 COMMENT
-    :   '/*' .*? '*/' -> skip
+    :   '/*' .*? '*/' -> channel(BLOCK_COMMENTS)
     ;
 
 LINE_COMMENT
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.java
index a3a2e20..06be9bc 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.java
@@ -132,6 +132,9 @@ public Vocabulary getVocabulary() {
 	}
 
 
+	    public static final int BLOCK_COMMENTS = 2;
+
+
 	public DroppingJavaLexer(CharStream input) {
 		super(input);
 		_interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
@@ -152,6 +155,21 @@ public DroppingJavaLexer(CharStream input) {
 	@Override
 	public ATN getATN() { return _ATN; }
 
+	@Override
+	public void action(RuleContext _localctx, int ruleIndex, int actionIndex) {
+		switch (ruleIndex) {
+		case 151:
+			COMMENT_action((RuleContext)_localctx, actionIndex);
+			break;
+		}
+	}
+	private void COMMENT_action(RuleContext _localctx, int actionIndex) {
+		switch (actionIndex) {
+		case 0:
+			_channel = BLOCK_COMMENTS;
+			break;
+		}
+	}
 	@Override
 	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
 		switch (ruleIndex) {
@@ -562,7 +580,7 @@ private boolean JavaLetterOrDigit_sempred(RuleContext _localctx, int predIndex)
 		"\3\2\2\2\u0432\u0434\13\2\2\2\u0433\u0432\3\2\2\2\u0434\u0437\3\2\2\2"+
 		"\u0435\u0436\3\2\2\2\u0435\u0433\3\2\2\2\u0436\u0438\3\2\2\2\u0437\u0435"+
 		"\3\2\2\2\u0438\u0439\7,\2\2\u0439\u043a\7\61\2\2\u043a\u043b\3\2\2\2\u043b"+
-		"\u043c\b\u0099\2\2\u043c\u0132\3\2\2\2\u043d\u043e\7\61\2\2\u043e\u043f"+
+		"\u043c\b\u0099\3\2\u043c\u0132\3\2\2\2\u043d\u043e\7\61\2\2\u043e\u043f"+
 		"\7\61\2\2\u043f\u0443\3\2\2\2\u0440\u0442\n\27\2\2\u0441\u0440\3\2\2\2"+
 		"\u0442\u0445\3\2\2\2\u0443\u0441\3\2\2\2\u0443\u0444\3\2\2\2\u0444\u0446"+
 		"\3\2\2\2\u0445\u0443\3\2\2\2\u0446\u0447\b\u009a\2\2\u0447\u0134\3\2\2"+
@@ -570,7 +588,7 @@ private boolean JavaLetterOrDigit_sempred(RuleContext _localctx, int predIndex)
 		"\u02bc\u02c0\u02c5\u02cd\u02d0\u02d7\u02db\u02df\u02e5\u02e8\u02ef\u02f3"+
 		"\u02fb\u02fe\u0305\u0309\u030d\u0312\u0315\u0318\u031d\u0320\u0325\u032a"+
 		"\u0332\u033d\u0341\u0346\u034a\u035a\u0364\u036a\u0371\u0375\u037b\u0388"+
-		"\u040f\u0418\u0420\u042b\u0435\u0443\3\b\2\2";
+		"\u040f\u0418\u0420\u042b\u0435\u0443\4\b\2\2\3\u0099\2";
 	public static final ATN _ATN =
 		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
 	static {
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
index 1c74560..5ada6f9 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
@@ -10,7 +10,7 @@
  */
 public class TargetMethod {
   private String name;
-  private Cutpoint cutpoint;
+  private Cutpoint cutpoint = Cutpoint.INSTEAD;     // by default cutpoint is INSTEAD
   private String text;
   private String resultType;
   private List<Argument> formalParams = new LinkedList<Argument>();
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
index 42a6697..2786733 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
@@ -1,11 +1,12 @@
 package ru.ftc.upc.testing.dropper.lang;
 
 import org.antlr.v4.runtime.ANTLRFileStream;
+import org.antlr.v4.runtime.BufferedTokenStream;
 import org.antlr.v4.runtime.CommonTokenStream;
-import org.antlr.v4.runtime.TokenStream;
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.ParseTreeWalker;
 import org.junit.Test;
+import ru.ftc.upc.testing.dropper.Cutpoint;
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaLexer;
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
 import ru.ftc.upc.testing.dropper.model.TargetsMap;
@@ -28,31 +29,31 @@ public void nestedClassesAreRecognizedFully() throws Exception {
     String actual = targetsMap.toString();
     System.out.println(actual);
     String expected = "ru.ftc.upc.testing.dropper.lang.droplets.MultiNestedClasses -> {\n" +
-            "\tTargetMethod{name='method1', cutpoint=null, resultType=int, formalParams=(), text=\n" +
+            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 1 ;\n" +
             "\t}\n" +
-            "\tTargetMethod{name='method4', cutpoint=null, resultType=int, formalParams=(), text=\n" +
+            "\tTargetMethod{name='method4', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 4 ;\n" +
             "\t}\n" +
-            "\tTargetMethod{name='method7', cutpoint=null, resultType=int, formalParams=(), text=\n" +
+            "\tTargetMethod{name='method7', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 7 ;\n" +
             "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.droplets.MultiNestedClasses$InnerClass1 -> {\n" +
-            "\tTargetMethod{name='method2', cutpoint=null, resultType=int, formalParams=(), text=\n" +
+            "\tTargetMethod{name='method2', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 2 ;\n" +
             "\t}\n" +
-            "\tTargetMethod{name='method3', cutpoint=null, resultType=int, formalParams=(), text=\n" +
+            "\tTargetMethod{name='method3', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 3 ;\n" +
             "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.droplets.MultiNestedClasses$InnerClass2 -> {\n" +
-            "\tTargetMethod{name='method5', cutpoint=null, resultType=int, formalParams=(), text=\n" +
+            "\tTargetMethod{name='method5', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 5 ;\n" +
             "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.droplets.MultiNestedClasses$InnerClass2$InnerClass3 -> {\n" +
-            "\tTargetMethod{name='method6', cutpoint=null, resultType=int, formalParams=(), text=\n" +
+            "\tTargetMethod{name='method6', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 6 ;\n" +
             "\t}\n" +
             "}\n";
@@ -66,27 +67,27 @@ public void methodHeadersAreRecognizedFully() throws Exception {
     String actual = targetsMap.toString();
     System.out.println(actual);
     String expected = "ru.ftc.upc.testing.dropper.lang.droplets.VariousMethodHeaders -> {\n" +
-            "\tTargetMethod{name='VariousMethodHeaders', cutpoint=null, resultType=null, formalParams=(), text=(empty)}\n" +
-            "\tTargetMethod{name='VariousMethodHeaders', cutpoint=null, resultType=null, formalParams=(Stack param1), text=(empty)}\n" +
-            "\tTargetMethod{name='VariousMethodHeaders', cutpoint=null, resultType=null, formalParams=(float arg), text=(empty)}\n" +
-            "\tTargetMethod{name='method1', cutpoint=null, resultType=void, formalParams=(), text=(empty)}\n" +
-            "\tTargetMethod{name='method2', cutpoint=null, resultType=void, formalParams=(int a), text=(empty)}\n" +
-            "\tTargetMethod{name='method3', cutpoint=null, resultType=void, formalParams=(Map map), text=(empty)}\n" +
-            "\tTargetMethod{name='method4', cutpoint=null, resultType=void, formalParams=(List xs), text=(empty)}\n" +
-            "\tTargetMethod{name='method5', cutpoint=null, resultType=void, formalParams=(UUID u1, Date d2), text=(empty)}\n" +
-            "\tTargetMethod{name='method6', cutpoint=null, resultType=void, formalParams=(double d1, double d2), text=(empty)}\n" +
-            "\tTargetMethod{name='method7', cutpoint=null, resultType=double, formalParams=(), text=\n" +
+            "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(), text=(empty)}\n" +
+            "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(Stack param1), text=(empty)}\n" +
+            "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(float arg), text=(empty)}\n" +
+            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
+            "\tTargetMethod{name='method2', cutpoint=INSTEAD, resultType=void, formalParams=(int a), text=(empty)}\n" +
+            "\tTargetMethod{name='method3', cutpoint=INSTEAD, resultType=void, formalParams=(Map map), text=(empty)}\n" +
+            "\tTargetMethod{name='method4', cutpoint=INSTEAD, resultType=void, formalParams=(List xs), text=(empty)}\n" +
+            "\tTargetMethod{name='method5', cutpoint=INSTEAD, resultType=void, formalParams=(UUID u1, Date d2), text=(empty)}\n" +
+            "\tTargetMethod{name='method6', cutpoint=INSTEAD, resultType=void, formalParams=(double d1, double d2), text=(empty)}\n" +
+            "\tTargetMethod{name='method7', cutpoint=INSTEAD, resultType=double, formalParams=(), text=\n" +
             "\t\treturn Math . random ( ) ;\n" +
             "\t}\n" +
-            "\tTargetMethod{name='method8', cutpoint=null, resultType=Set, formalParams=(EventObject eo), text=\n" +
+            "\tTargetMethod{name='method8', cutpoint=INSTEAD, resultType=Set, formalParams=(EventObject eo), text=\n" +
             "\t\treturn Collections . emptySet ( ) ;\n" +
             "\t}\n" +
-            "\tTargetMethod{name='method9', cutpoint=null, resultType=T, formalParams=(T source, boolean flag), text=\n" +
+            "\tTargetMethod{name='method9', cutpoint=INSTEAD, resultType=T, formalParams=(T source, boolean flag), text=\n" +
             "\t\treturn ( T ) new BufferedInputStream ( source ) ;\n" +
             "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.droplets.VariousMethodHeaders$InnerClass -> {\n" +
-            "\tTargetMethod{name='InnerClass', cutpoint=null, resultType=null, formalParams=(Deque arg), text=(empty)}\n" +
+            "\tTargetMethod{name='InnerClass', cutpoint=INSTEAD, resultType=null, formalParams=(Deque arg), text=(empty)}\n" +
             "}\n";
     assertEquals(expected, actual);
   }
@@ -98,11 +99,11 @@ public void methodBodiesAreRecognizedFully() throws Exception {
     String actual = targetsMap.toString();
     System.out.println(actual);
     String expected = "ru.ftc.upc.testing.dropper.lang.droplets.MethodBodies -> {\n" +
-            "\tTargetMethod{name='MethodBodies', cutpoint=null, resultType=null, formalParams=(String name), text=\n" +
+            "\tTargetMethod{name='MethodBodies', cutpoint=INSTEAD, resultType=null, formalParams=(String name), text=\n" +
             "\t\tSystem . out . println ( \"Hello from constructor :) \" ) ;\n" +
             "\t}\n" +
-            "\tTargetMethod{name='MethodBodies', cutpoint=null, resultType=null, formalParams=(), text=(empty)}\n" +
-            "\tTargetMethod{name='method1', cutpoint=null, resultType=boolean, formalParams=(), text=\n" +
+            "\tTargetMethod{name='MethodBodies', cutpoint=INSTEAD, resultType=null, formalParams=(), text=(empty)}\n" +
+            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=boolean, formalParams=(), text=\n" +
             "\t\tif ( Math . random ( ) > 0.5d ) { return true ; } else { return false ; }\n" +
             "\t}\n" +
             "}\n";
@@ -116,15 +117,15 @@ public void enumTypesAreRecognizedFully() throws Exception {
     String actual = targetsMap.toString();
     System.out.println(actual);
     String expected = "ru.ftc.upc.testing.dropper.lang.droplets.RootEnumeration -> {\n" +
-            "\tTargetMethod{name='RootEnumeration', cutpoint=null, resultType=null, formalParams=(), text=\n" +
+            "\tTargetMethod{name='RootEnumeration', cutpoint=INSTEAD, resultType=null, formalParams=(), text=\n" +
             "\t\tString nothing = \"I'm the most enumerated constructor ever!\" ;\n" +
             "\t}\n" +
-            "\tTargetMethod{name='getByName', cutpoint=null, resultType=RootEnumeration, formalParams=(String name), text=\n" +
+            "\tTargetMethod{name='getByName', cutpoint=INSTEAD, resultType=RootEnumeration, formalParams=(String name), text=\n" +
             "\t\tfor ( RootEnumeration rootEnum : values ( ) ) { if ( rootEnum . toString ( ) . equals ( name ) ) { return rootEnum ; } } throw new IllegalArgumentException ( \"Not found: \" + name ) ;\n" +
             "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.droplets.RootEnumeration$InnerEnum -> {\n" +
-            "\tTargetMethod{name='isTheSame', cutpoint=null, resultType=boolean, formalParams=(Enum e), text=\n" +
+            "\tTargetMethod{name='isTheSame', cutpoint=INSTEAD, resultType=boolean, formalParams=(Enum e), text=\n" +
             "\t\treturn INNER_ENUM . toString ( ) . equals ( e . toString ( ) ) ;\n" +
             "\t}\n" +
             "}\n";
@@ -138,23 +139,23 @@ public void interfaceTypesAreRecognizedFully() throws Exception {
     String actual = targetsMap.toString();
     System.out.println(actual);
     String expected = "ru.ftc.upc.testing.dropper.lang.RootInterface -> {\n" +
-            "\tTargetMethod{name='method1', cutpoint=null, resultType=void, formalParams=(), text=(empty)}\n" +
-            "\tTargetMethod{name='method2', cutpoint=null, resultType=boolean, formalParams=(int two), text=(empty)}\n" +
-            "\tTargetMethod{name='method3', cutpoint=null, resultType=RootInterface, formalParams=(Set longs), text=(empty)}\n" +
-            "\tTargetMethod{name='method5', cutpoint=null, resultType=double, formalParams=(Float param1), text=\n" +
+            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
+            "\tTargetMethod{name='method2', cutpoint=INSTEAD, resultType=boolean, formalParams=(int two), text=(empty)}\n" +
+            "\tTargetMethod{name='method3', cutpoint=INSTEAD, resultType=RootInterface, formalParams=(Set longs), text=(empty)}\n" +
+            "\tTargetMethod{name='method5', cutpoint=INSTEAD, resultType=double, formalParams=(Float param1), text=\n" +
             "\t\treturn Math . random ( ) ;\n" +
             "\t}\n" +
-            "\tTargetMethod{name='newObservable', cutpoint=null, resultType=Observable, formalParams=(List lof), text=\n" +
+            "\tTargetMethod{name='newObservable', cutpoint=INSTEAD, resultType=Observable, formalParams=(List lof), text=\n" +
             "\t\treturn new Observable ( ) ;\n" +
             "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.RootInterface$InnerIface -> {\n" +
-            "\tTargetMethod{name='method1', cutpoint=null, resultType=InputStream, formalParams=(), text=\n" +
+            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=InputStream, formalParams=(), text=\n" +
             "\t\treturn new FileInputStream ( \"\" ) ;\n" +
             "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.RootInterface$InnerIface$InnerInnerIface -> {\n" +
-            "\tTargetMethod{name='method1', cutpoint=null, resultType=OutputStream, formalParams=(), text=\n" +
+            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=OutputStream, formalParams=(), text=\n" +
             "\t\treturn new FileOutputStream ( \"\" ) ;\n" +
             "\t}\n" +
             "}\n";
@@ -168,38 +169,38 @@ public void typesCombinationsAreRecognizedFully() throws Exception {
     String actual = targetsMap.toString();
     System.out.println(actual);
     String expected = "ru.ftc.upc.testing.dropper.lang.droplets.SiblingClass -> {\n" +
-            "\tTargetMethod{name='method', cutpoint=null, resultType=double, formalParams=(), text=\n" +
+            "\tTargetMethod{name='method', cutpoint=INSTEAD, resultType=double, formalParams=(), text=\n" +
             "\t\treturn Math . random ( ) ;\n" +
             "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.droplets.SiblingEnum -> {\n" +
-            "\tTargetMethod{name='SiblingEnum', cutpoint=null, resultType=null, formalParams=(), text=(empty)}\n" +
-            "\tTargetMethod{name='getMe', cutpoint=null, resultType=SiblingEnum, formalParams=(), text=\n" +
+            "\tTargetMethod{name='SiblingEnum', cutpoint=INSTEAD, resultType=null, formalParams=(), text=(empty)}\n" +
+            "\tTargetMethod{name='getMe', cutpoint=INSTEAD, resultType=SiblingEnum, formalParams=(), text=\n" +
             "\t\treturn this ;\n" +
             "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.droplets.SiblingEnum$InnerInterface -> {\n" +
-            "\tTargetMethod{name='getThatEnum', cutpoint=null, resultType=TypesCombination.InnerInterface.InnerInnerClass.InnerInnerInnerEnum, formalParams=(), text=(empty)}\n" +
+            "\tTargetMethod{name='getThatEnum', cutpoint=INSTEAD, resultType=TypesCombination.InnerInterface.InnerInnerClass.InnerInnerInnerEnum, formalParams=(), text=(empty)}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.droplets.SiblingInterface -> {\n" +
-            "\tTargetMethod{name='method', cutpoint=null, resultType=Vector, formalParams=(Vector arg), text=(empty)}\n" +
+            "\tTargetMethod{name='method', cutpoint=INSTEAD, resultType=Vector, formalParams=(Vector arg), text=(empty)}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.droplets.SiblingInterface$InnerEnum -> {\n" +
-            "\tTargetMethod{name='InnerEnum', cutpoint=null, resultType=null, formalParams=(), text=(empty)}\n" +
+            "\tTargetMethod{name='InnerEnum', cutpoint=INSTEAD, resultType=null, formalParams=(), text=(empty)}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.droplets.TypesCombination -> {\n" +
-            "\tTargetMethod{name='method1', cutpoint=null, resultType=void, formalParams=(), text=\n" +
+            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=\n" +
             "\t\tSystem . console ( ) ;\n" +
             "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.droplets.TypesCombination$InnerInterface -> {\n" +
-            "\tTargetMethod{name='innerMethod', cutpoint=null, resultType=void, formalParams=(), text=(empty)}\n" +
+            "\tTargetMethod{name='innerMethod', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.droplets.TypesCombination$InnerInterface$InnerInnerClass -> {\n" +
-            "\tTargetMethod{name='innerInnerMethod', cutpoint=null, resultType=void, formalParams=(), text=(empty)}\n" +
+            "\tTargetMethod{name='innerInnerMethod', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.droplets.TypesCombination$InnerInterface$InnerInnerClass$InnerInnerInnerEnum -> {\n" +
-            "\tTargetMethod{name='doSomething', cutpoint=null, resultType=void, formalParams=(), text=(empty)}\n" +
+            "\tTargetMethod{name='doSomething', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n";
     assertEquals(expected, actual);
   }
@@ -224,14 +225,32 @@ public void importsOnDemandAreNotSupported() throws Exception {
     System.out.println(actual);
   }
 
+  @Test
+  public void afterCutpointIsRecognizedFully() throws Exception {
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/AfterCutpoint.java";
+    TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
+    Cutpoint actual = targetsMap.entrySet().iterator().next().getValue().getFirst().getCutpoint();
+    System.out.printf("Actual cutpoint: %s\n", actual);
+    assertEquals(Cutpoint.AFTER, actual);
+  }
+
+  @Test
+  public void defaultCutpointIsAppliedCorrectly() throws Exception {
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/DefaultCutpoint.java";
+    TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
+    Cutpoint actual = targetsMap.entrySet().iterator().next().getValue().getFirst().getCutpoint();
+    System.out.printf("Actual cutpoint (default): %s\n", actual);
+    assertEquals(Cutpoint.INSTEAD, actual);
+  }
+
   private DropletAssembler loadDroplet(String dropletPath) throws IOException {
     ANTLRFileStream fileStream = new ANTLRFileStream(dropletPath);
     DroppingJavaLexer lexer = new DroppingJavaLexer(fileStream);
-    TokenStream tokenStream = new CommonTokenStream(lexer);
+    BufferedTokenStream tokenStream = new CommonTokenStream(lexer);
     DroppingJavaParser parser = new DroppingJavaParser(tokenStream);
     ParseTree tree = parser.compilationUnit();
 
-    DropletAssembler listener = new DropletAssembler();
+    DropletAssembler listener = new DropletAssembler(tokenStream);
     ParseTreeWalker walker = new ParseTreeWalker();
     walker.walk(listener, tree);
 

From f8573e017ad020be557f6bc522b252a9532ed72b Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Fri, 3 Jun 2016 01:02:54 +0600
Subject: [PATCH 09/22] UPCSEC-0000 Accompanying refactoring

---
 .../ru/ftc/upc/testing/dropper/Cutpoint.java  | 19 ++++++++++++-------
 .../ru/ftc/upc/testing/dropper/Droplet.java   |  4 ++--
 .../ftc/upc/testing/dropper/DropperAgent.java |  2 +-
 .../upc/testing/dropper/MethodPatcher.java    | 12 ------------
 .../testing/dropper/PatchingTransformer.java  |  9 +++++----
 .../upc/testing/dropper/model/TargetsMap.java |  4 ++--
 .../AfterBodyModifier.java}                   |  7 ++++---
 .../BeforeBodyModifier.java}                  |  7 ++++---
 .../InsteadBodyModifier.java}                 |  7 ++++---
 .../dropper/modify/MethodModifier.java        | 13 +++++++++++++
 10 files changed, 47 insertions(+), 37 deletions(-)
 delete mode 100644 src/main/java/ru/ftc/upc/testing/dropper/MethodPatcher.java
 rename src/main/java/ru/ftc/upc/testing/dropper/{AfterMethodPatcher.java => modify/AfterBodyModifier.java} (54%)
 rename src/main/java/ru/ftc/upc/testing/dropper/{BeforeMethodPatcher.java => modify/BeforeBodyModifier.java} (54%)
 rename src/main/java/ru/ftc/upc/testing/dropper/{InsteadMethodPatcher.java => modify/InsteadBodyModifier.java} (53%)
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/modify/MethodModifier.java

diff --git a/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java b/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java
index f68637e..0b8043b 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java
@@ -1,18 +1,23 @@
 package ru.ftc.upc.testing.dropper;
 
+import ru.ftc.upc.testing.dropper.modify.AfterBodyModifier;
+import ru.ftc.upc.testing.dropper.modify.BeforeBodyModifier;
+import ru.ftc.upc.testing.dropper.modify.InsteadBodyModifier;
+import ru.ftc.upc.testing.dropper.modify.MethodModifier;
+
 /**
- * Created by Plizga on 29.04.2016 11:59
+ * Created by Toparvion on 29.04.2016 11:59
  */
 @SuppressWarnings("unused")       // all the elements of the Enum is actually used through Enum#valueOf()
 public enum Cutpoint {
-  BEFORE(BeforeMethodPatcher.class),
-  INSTEAD(InsteadMethodPatcher.class),
-  AFTER(AfterMethodPatcher.class),
-  CATCH(MethodPatcher.class);           // TODO implement dedicated patcher
+  BEFORE(BeforeBodyModifier.class),
+  INSTEAD(InsteadBodyModifier.class),
+  AFTER(AfterBodyModifier.class),
+  CATCH(MethodModifier.class);           // TODO implement dedicated patcher
 
-  final Class<? extends MethodPatcher> patcherClass;
+  final Class<? extends MethodModifier> patcherClass;
 
-  Cutpoint(Class<? extends MethodPatcher> patcherClass) {
+  Cutpoint(Class<? extends MethodModifier> patcherClass) {
     this.patcherClass = patcherClass;
   }
 
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/Droplet.java b/src/main/java/ru/ftc/upc/testing/dropper/Droplet.java
index f655002..0b32f28 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/Droplet.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/Droplet.java
@@ -1,9 +1,9 @@
 package ru.ftc.upc.testing.dropper;
 
 /**
- * Created by Plizga on 29.04.2016 11:58
+ * Created by Toparvion on 29.04.2016 11:58
  */
-class Droplet {
+public class Droplet {
   private String clazz;
   private String method;
   private Cutpoint cutpoint;
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java b/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java
index a7abcc6..e4ce050 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java
@@ -16,7 +16,7 @@
 import static java.lang.String.format;
 
 /**
- * Created by Plizga on 28.04.2016 9:13
+ * Created by Toparvion on 28.04.2016 9:13
  */
 @SuppressWarnings("unused")
 public class DropperAgent {
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/MethodPatcher.java b/src/main/java/ru/ftc/upc/testing/dropper/MethodPatcher.java
deleted file mode 100644
index 9226760..0000000
--- a/src/main/java/ru/ftc/upc/testing/dropper/MethodPatcher.java
+++ /dev/null
@@ -1,12 +0,0 @@
-package ru.ftc.upc.testing.dropper;
-
-import javassist.CannotCompileException;
-import javassist.CtMethod;
-
-/**
- * Created by Plizga on 29.04.2016 14:38
- */
-interface MethodPatcher {
-
-  void apply(CtMethod method, Droplet droplet) throws CannotCompileException;
-}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java b/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java
index 85e1ed4..724bcfc 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java
@@ -6,6 +6,7 @@
 import javassist.CtMethod;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import ru.ftc.upc.testing.dropper.modify.MethodModifier;
 
 import java.lang.instrument.ClassFileTransformer;
 import java.lang.instrument.IllegalClassFormatException;
@@ -17,7 +18,7 @@
 import static java.lang.String.format;
 
 /**
- * Created by Plizga on 29.04.2016 12:50
+ * Created by Toparvion on 29.04.2016 12:50
  */
 class PatchingTransformer implements ClassFileTransformer {
   private static final Logger log = LoggerFactory.getLogger(PatchingTransformer.class);
@@ -47,7 +48,7 @@ public byte[] transform(ClassLoader loader,
       return applyDroplet(dropletMap.get(className), classFileBuffer);
 
     } catch (Exception e) {
-      log.error(format("Failed to patch class '%s'. Class skipped.", className), e);
+      log.error(format("Failed to modify class '%s'. Class skipped.", className), e);
       return null;
     }
   }
@@ -62,10 +63,10 @@ private byte[] applyDroplet(Droplet droplet, byte[] classFileBuffer) throws Exce
     CtMethod ctMethod = ctClass.getDeclaredMethod(droplet.getMethod());
 
     Cutpoint cutpoint = droplet.getCutpoint();
-    MethodPatcher patcher = cutpoint.patcherClass.newInstance();
+    MethodModifier patcher = cutpoint.patcherClass.newInstance();
 
     patcher.apply(ctMethod, droplet);
-    log.info("Class {} has been patched with {}.", ctClass.getName(), patcher.getClass().getSimpleName());
+    log.info("Class {} has been modified with {}.", ctClass.getName(), patcher.getClass().getSimpleName());
     return ctClass.toBytecode();
   }
 }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java
index 2747b2c..fa48afa 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java
@@ -1,14 +1,14 @@
 package ru.ftc.upc.testing.dropper.model;
 
 import java.util.Deque;
+import java.util.LinkedHashMap;
 import java.util.LinkedList;
 import java.util.Map;
-import java.util.TreeMap;
 
 /**
  * @author Toparvion
  */
-public class TargetsMap extends TreeMap<String, Deque<TargetMethod>> {
+public class TargetsMap extends LinkedHashMap<String, Deque<TargetMethod>> {
 
   public void put(String key, TargetMethod method) {
     Deque<TargetMethod> methods = this.get(key);
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/AfterMethodPatcher.java b/src/main/java/ru/ftc/upc/testing/dropper/modify/AfterBodyModifier.java
similarity index 54%
rename from src/main/java/ru/ftc/upc/testing/dropper/AfterMethodPatcher.java
rename to src/main/java/ru/ftc/upc/testing/dropper/modify/AfterBodyModifier.java
index f75ed07..d375249 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/AfterMethodPatcher.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/modify/AfterBodyModifier.java
@@ -1,12 +1,13 @@
-package ru.ftc.upc.testing.dropper;
+package ru.ftc.upc.testing.dropper.modify;
 
 import javassist.CannotCompileException;
 import javassist.CtMethod;
+import ru.ftc.upc.testing.dropper.Droplet;
 
 /**
- * Created by Plizga on 29.04.2016 14:51
+ * Created by Toparvion on 29.04.2016 14:51
  */
-class AfterMethodPatcher implements MethodPatcher {
+public class AfterBodyModifier implements MethodModifier {
 
   @Override
   public void apply(CtMethod method, Droplet droplet) throws CannotCompileException {
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/BeforeMethodPatcher.java b/src/main/java/ru/ftc/upc/testing/dropper/modify/BeforeBodyModifier.java
similarity index 54%
rename from src/main/java/ru/ftc/upc/testing/dropper/BeforeMethodPatcher.java
rename to src/main/java/ru/ftc/upc/testing/dropper/modify/BeforeBodyModifier.java
index 8c5c4db..dd15eb2 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/BeforeMethodPatcher.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/modify/BeforeBodyModifier.java
@@ -1,12 +1,13 @@
-package ru.ftc.upc.testing.dropper;
+package ru.ftc.upc.testing.dropper.modify;
 
 import javassist.CannotCompileException;
 import javassist.CtMethod;
+import ru.ftc.upc.testing.dropper.Droplet;
 
 /**
- * Created by Plizga on 29.04.2016 14:44
+ * Created by Toparvion on 29.04.2016 14:44
  */
-class BeforeMethodPatcher implements MethodPatcher {
+public class BeforeBodyModifier implements MethodModifier {
 
   @Override
   public void apply(CtMethod method, Droplet droplet) throws CannotCompileException {
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/InsteadMethodPatcher.java b/src/main/java/ru/ftc/upc/testing/dropper/modify/InsteadBodyModifier.java
similarity index 53%
rename from src/main/java/ru/ftc/upc/testing/dropper/InsteadMethodPatcher.java
rename to src/main/java/ru/ftc/upc/testing/dropper/modify/InsteadBodyModifier.java
index e2ecbcb..eed6ca1 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/InsteadMethodPatcher.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/modify/InsteadBodyModifier.java
@@ -1,12 +1,13 @@
-package ru.ftc.upc.testing.dropper;
+package ru.ftc.upc.testing.dropper.modify;
 
 import javassist.CannotCompileException;
 import javassist.CtMethod;
+import ru.ftc.upc.testing.dropper.Droplet;
 
 /**
- * Created by Plizga on 29.04.2016 14:45
+ * Created by Toparvion on 29.04.2016 14:45
  */
-class InsteadMethodPatcher implements MethodPatcher {
+public class InsteadBodyModifier implements MethodModifier {
 
   @Override
   public void apply(CtMethod method, Droplet droplet) throws CannotCompileException {
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/modify/MethodModifier.java b/src/main/java/ru/ftc/upc/testing/dropper/modify/MethodModifier.java
new file mode 100644
index 0000000..d5a169e
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/modify/MethodModifier.java
@@ -0,0 +1,13 @@
+package ru.ftc.upc.testing.dropper.modify;
+
+import javassist.CannotCompileException;
+import javassist.CtMethod;
+import ru.ftc.upc.testing.dropper.Droplet;
+
+/**
+ * Created by Toparvion on 29.04.2016 14:38
+ */
+public interface MethodModifier {
+
+  void apply(CtMethod method, Droplet droplet) throws CannotCompileException;
+}

From 58fb897a27a6ea3711feef259e37449cbb152291 Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Fri, 3 Jun 2016 23:31:32 +0600
Subject: [PATCH 10/22] UPCSEC-0000 Implemented resolving simple type names
 into fully qualified equivalents within method's bodies + Added a number of
 samples for language recognition unit testing

---
 .gitignore                                    |  3 -
 .../dropper/lang/DropletAssembler.java        | 99 +++++++++++++------
 .../dropper/lang/DropletAssemblerTest.java    | 97 ++++++++++--------
 .../dropper/lang/samples/AfterCutpoint.java   | 26 +++++
 .../dropper/lang/samples/DefaultCutpoint.java | 24 +++++
 .../dropper/lang/samples/MethodBodies.java    | 26 +++++
 .../lang/samples/MultiNestedClasses.java      | 33 +++++++
 .../dropper/lang/samples/RootEnumeration.java | 34 +++++++
 .../lang/samples/TypesCombination.java        | 71 +++++++++++++
 .../lang/samples/VariousMethodHeaders.java    | 53 ++++++++++
 src/test/resources/DPClientImpl.java          | 40 ++++++++
 src/test/resources/FaultyImports.java         |  2 +-
 .../resources/FaultyTypesCombination.java     |  2 +-
 src/test/resources/Imports.java               |  2 +-
 14 files changed, 438 insertions(+), 74 deletions(-)
 create mode 100644 src/test/java/ru/ftc/upc/testing/dropper/lang/samples/AfterCutpoint.java
 create mode 100644 src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DefaultCutpoint.java
 create mode 100644 src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MethodBodies.java
 create mode 100644 src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses.java
 create mode 100644 src/test/java/ru/ftc/upc/testing/dropper/lang/samples/RootEnumeration.java
 create mode 100644 src/test/java/ru/ftc/upc/testing/dropper/lang/samples/TypesCombination.java
 create mode 100644 src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java
 create mode 100644 src/test/resources/DPClientImpl.java

diff --git a/.gitignore b/.gitignore
index 767fece..77849f6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -85,7 +85,4 @@ fabric.properties
 # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
 hs_err_pid*
 
-# droplets themselves are not the part of Dropper
-droplets/
-
 memo.txt
\ No newline at end of file
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
index 24ba6a3..1e392f7 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
@@ -11,8 +11,12 @@
 import ru.ftc.upc.testing.dropper.model.TargetsMap;
 
 import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 /**
+ * The main class responsible for extracting valuable data from droplet files. Built upon ANTLR parse tree event
+ * listener.
  * @author Toparvion
  */
 class DropletAssembler extends DroppingJavaBaseListener {
@@ -34,7 +38,7 @@ class DropletAssembler extends DroppingJavaBaseListener {
    */
   private String packageDeclaration = "";
   /**
-   * Internal data structure aimed to support depth tracking during parse tree traversing.
+   * Internal stack aimed to support depth tracking during parse tree traversing.
    */
   private final Deque<String> classNameStack = new LinkedList<String>();
   /**
@@ -46,7 +50,7 @@ class DropletAssembler extends DroppingJavaBaseListener {
     this.tokenStream = tokenStream;
   }
 
-  //region parse tree event listener methods
+  //region Parse tree event listener methods
   @Override
   public void enterPackageDeclaration(DroppingJavaParser.PackageDeclarationContext ctx) {
     StringBuilder sb = new StringBuilder();
@@ -56,6 +60,29 @@ public void enterPackageDeclaration(DroppingJavaParser.PackageDeclarationContext
     this.packageDeclaration = sb.toString();
   }
 
+  @Override
+  public void enterSingleTypeImportDeclaration(DroppingJavaParser.SingleTypeImportDeclarationContext ctx) {
+    DroppingJavaParser.TypeNameContext typeName = ctx.typeName();
+    if (typeName.packageOrTypeName() == null) {
+      // in this case there is no profit in mapping a type to its import prefix so that we just ignore it
+      return;
+    }
+    importsMap.put(typeName.Identifier().getText(), typeName.packageOrTypeName().getText());
+  }
+
+  /**
+   * Type imports on demand are not supported in this version because they introduce quite complicated ambiguity. In
+   * order not to mute their existence we prefer to explicitly inform the user about them with the help of exception.
+   */
+  @Override
+  public void enterTypeImportOnDemandDeclaration(DroppingJavaParser.TypeImportOnDemandDeclarationContext ctx) {
+    Token offendingToken = ctx.getToken(DroppingJavaParser.IMPORT, 0).getSymbol();
+    String offendingImportString = String.format("import %s.*;", ctx.packageOrTypeName().getText());
+    throw new DropletFormatException(String.format("Line %d:%d. Type imports on demand are not supported: '%s'. " +
+                    "Please replace it with a set of single type imports.",
+            offendingToken.getLine(), offendingToken.getCharPositionInLine(), offendingImportString));
+  }
+
   @Override
   public void enterNormalClassDeclaration(DroppingJavaParser.NormalClassDeclarationContext ctx) {
     classNameStack.push(ctx.Identifier().getText());
@@ -127,35 +154,13 @@ public void enterBlockStatements(DroppingJavaParser.BlockStatementsContext ctx)
     DroppingJavaVisitor<String> visitor = new BodyComposingVisitor();
 
     String bodyText = visitor.visit(ctx);
+    bodyText = makeTypeNamesFullyQualified(bodyText);
     TargetMethod currentMethod = targetsMap.get(composeCurrentKey()).getLast();
     currentMethod.setText(bodyText);
   }
-
-  @Override
-  public void enterSingleTypeImportDeclaration(DroppingJavaParser.SingleTypeImportDeclarationContext ctx) {
-    DroppingJavaParser.TypeNameContext typeName = ctx.typeName();
-    if (typeName.packageOrTypeName() == null) {
-      // in this case there is no profit in mapping a type to its import prefix so that we just ignore it
-      return;
-    }
-    importsMap.put(typeName.Identifier().getText(), typeName.packageOrTypeName().getText());
-  }
-
-  /**
-   * Type imports on demand are not supported in this version because they introduce quite complicated ambiguity. In
-   * order not to mute their existence we prefer to explicitly inform the user about them with the help of exception.
-   */
-  @Override
-  public void enterTypeImportOnDemandDeclaration(DroppingJavaParser.TypeImportOnDemandDeclarationContext ctx) {
-    Token offendingToken = ctx.getToken(DroppingJavaParser.IMPORT, 0).getSymbol();
-    String offendingImportString = String.format("import %s.*;", ctx.packageOrTypeName().getText());
-    throw new DropletFormatException(String.format("Line %d:%d. Type imports on demand are not supported: '%s'. " +
-            "Please replace it with a set of single type imports.",
-            offendingToken.getLine(), offendingToken.getCharPositionInLine(), offendingImportString));
-  }
   //endregion
 
-  //region auxiliary methods of the assembler
+  //region Auxiliary methods of the assembler
   /**
    * Extracts formal parameters types and names and stores them into the given target method.
    * @param method target method to store extracted parameters into
@@ -243,7 +248,7 @@ private String extractCutpointString(ParserRuleContext ctx) {
   }
 
   /**
-   * @return an actual key for targets map (composed basing on current state of the stack)
+   * @return an actual key for targets map (composed basing on current state of the {@linkplain #classNameStack})
    */
   private String composeCurrentKey() {
     StringBuilder sb = new StringBuilder(packageDeclaration);
@@ -260,9 +265,47 @@ private String composeCurrentKey() {
 
     return sb.toString();
   }
+
+  /**
+   * Replaces all the type names in {@code bodyText} with their fully qualified equivalents according to
+   * {@link #importsMap} of the droplet. Skips names that are already fully qualified.
+   * Does nothing if some type has no import.
+   * @param bodyText text of method's body being processed
+   * @return the {@code bodyText} with fully qualified type names
+   */
+  private String makeTypeNamesFullyQualified(String bodyText) {
+    if (bodyText == null || bodyText.isEmpty())
+      return bodyText;
+    String processedText = bodyText;
+    for (Map.Entry<String, String> importEntry : importsMap.entrySet()) {
+      String simpleName = importEntry.getKey();
+      String fqName = importEntry.getValue() + "." + simpleName;
+      Pattern pattern = Pattern.compile("(\\b)" + simpleName + "(\\b)");
+      Matcher matcher = pattern.matcher(processedText);
+      StringBuffer sb = new StringBuffer(bodyText.length()+30);
+      while (matcher.find()) {
+        if (!isNameAlreadyQualified(processedText, matcher.start(2), fqName)) {
+          matcher.appendReplacement(sb, "$1" + fqName + "$2");
+        }
+      }
+      matcher.appendTail(sb);
+      processedText = sb.toString();
+    }
+    return processedText;
+  }
+
+  /**
+   * Detects whether type name on position denoted by {@code typeNameEndPosition} is fully qualified.
+   */
+  private boolean isNameAlreadyQualified(String wholeText, int typeNameEndPosition, String typeFqName) {
+    String sparseFqName = typeFqName.replaceAll("\\.", " . ");
+    int precursorStartPosition = Math.max(0, (typeNameEndPosition - sparseFqName.length()));
+    String precursor = wholeText.substring(precursorStartPosition, typeNameEndPosition);
+    return sparseFqName.equals(precursor);
+  }
   //endregion
 
-  //region getters
+  //region Getters
   TargetsMap getTargetsMap() {
     return targetsMap;
   }
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
index 2786733..e5ee833 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
@@ -24,11 +24,11 @@ public class DropletAssemblerTest {
 
   @Test
   public void nestedClassesAreRecognizedFully() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/MultiNestedClasses.java";
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     System.out.println(actual);
-    String expected = "ru.ftc.upc.testing.dropper.lang.droplets.MultiNestedClasses -> {\n" +
+    String expected = "ru.ftc.upc.testing.dropper.lang.samples.MultiNestedClasses -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 1 ;\n" +
             "\t}\n" +
@@ -39,7 +39,7 @@ public void nestedClassesAreRecognizedFully() throws Exception {
             "\t\treturn 7 ;\n" +
             "\t}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.droplets.MultiNestedClasses$InnerClass1 -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.samples.MultiNestedClasses$InnerClass1 -> {\n" +
             "\tTargetMethod{name='method2', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 2 ;\n" +
             "\t}\n" +
@@ -47,12 +47,12 @@ public void nestedClassesAreRecognizedFully() throws Exception {
             "\t\treturn 3 ;\n" +
             "\t}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.droplets.MultiNestedClasses$InnerClass2 -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.samples.MultiNestedClasses$InnerClass2 -> {\n" +
             "\tTargetMethod{name='method5', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 5 ;\n" +
             "\t}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.droplets.MultiNestedClasses$InnerClass2$InnerClass3 -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.samples.MultiNestedClasses$InnerClass2$InnerClass3 -> {\n" +
             "\tTargetMethod{name='method6', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 6 ;\n" +
             "\t}\n" +
@@ -62,11 +62,11 @@ public void nestedClassesAreRecognizedFully() throws Exception {
 
   @Test
   public void methodHeadersAreRecognizedFully() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/VariousMethodHeaders.java";
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     System.out.println(actual);
-    String expected = "ru.ftc.upc.testing.dropper.lang.droplets.VariousMethodHeaders -> {\n" +
+    String expected = "ru.ftc.upc.testing.dropper.lang.samples.VariousMethodHeaders -> {\n" +
             "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(), text=(empty)}\n" +
             "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(Stack param1), text=(empty)}\n" +
             "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(float arg), text=(empty)}\n" +
@@ -80,13 +80,16 @@ public void methodHeadersAreRecognizedFully() throws Exception {
             "\t\treturn Math . random ( ) ;\n" +
             "\t}\n" +
             "\tTargetMethod{name='method8', cutpoint=INSTEAD, resultType=Set, formalParams=(EventObject eo), text=\n" +
-            "\t\treturn Collections . emptySet ( ) ;\n" +
+            "\t\treturn java.util.Collections . emptySet ( ) ;\n" +
             "\t}\n" +
             "\tTargetMethod{name='method9', cutpoint=INSTEAD, resultType=T, formalParams=(T source, boolean flag), text=\n" +
-            "\t\treturn ( T ) new BufferedInputStream ( source ) ;\n" +
+            "\t\treturn ( T ) new java.io.BufferedInputStream ( source ) ;\n" +
+            "\t}\n" +
+            "\tTargetMethod{name='method10', cutpoint=INSTEAD, resultType=Map.Entry, formalParams=(Map.Entry arg), text=\n" +
+            "\t\treturn new java.util.AbstractMap . SimpleEntry < Long , String > ( 23L , \"\" ) ;\n" +
             "\t}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.droplets.VariousMethodHeaders$InnerClass -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.samples.VariousMethodHeaders$InnerClass -> {\n" +
             "\tTargetMethod{name='InnerClass', cutpoint=INSTEAD, resultType=null, formalParams=(Deque arg), text=(empty)}\n" +
             "}\n";
     assertEquals(expected, actual);
@@ -94,11 +97,11 @@ public void methodHeadersAreRecognizedFully() throws Exception {
 
   @Test
   public void methodBodiesAreRecognizedFully() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/MethodBodies.java";
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MethodBodies.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     System.out.println(actual);
-    String expected = "ru.ftc.upc.testing.dropper.lang.droplets.MethodBodies -> {\n" +
+    String expected = "ru.ftc.upc.testing.dropper.lang.samples.MethodBodies -> {\n" +
             "\tTargetMethod{name='MethodBodies', cutpoint=INSTEAD, resultType=null, formalParams=(String name), text=\n" +
             "\t\tSystem . out . println ( \"Hello from constructor :) \" ) ;\n" +
             "\t}\n" +
@@ -112,11 +115,11 @@ public void methodBodiesAreRecognizedFully() throws Exception {
 
   @Test
   public void enumTypesAreRecognizedFully() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/RootEnumeration.java";
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/RootEnumeration.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     System.out.println(actual);
-    String expected = "ru.ftc.upc.testing.dropper.lang.droplets.RootEnumeration -> {\n" +
+    String expected = "ru.ftc.upc.testing.dropper.lang.samples.RootEnumeration -> {\n" +
             "\tTargetMethod{name='RootEnumeration', cutpoint=INSTEAD, resultType=null, formalParams=(), text=\n" +
             "\t\tString nothing = \"I'm the most enumerated constructor ever!\" ;\n" +
             "\t}\n" +
@@ -124,7 +127,7 @@ public void enumTypesAreRecognizedFully() throws Exception {
             "\t\tfor ( RootEnumeration rootEnum : values ( ) ) { if ( rootEnum . toString ( ) . equals ( name ) ) { return rootEnum ; } } throw new IllegalArgumentException ( \"Not found: \" + name ) ;\n" +
             "\t}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.droplets.RootEnumeration$InnerEnum -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.samples.RootEnumeration$InnerEnum -> {\n" +
             "\tTargetMethod{name='isTheSame', cutpoint=INSTEAD, resultType=boolean, formalParams=(Enum e), text=\n" +
             "\t\treturn INNER_ENUM . toString ( ) . equals ( e . toString ( ) ) ;\n" +
             "\t}\n" +
@@ -146,17 +149,17 @@ public void interfaceTypesAreRecognizedFully() throws Exception {
             "\t\treturn Math . random ( ) ;\n" +
             "\t}\n" +
             "\tTargetMethod{name='newObservable', cutpoint=INSTEAD, resultType=Observable, formalParams=(List lof), text=\n" +
-            "\t\treturn new Observable ( ) ;\n" +
+            "\t\treturn new java.util.Observable ( ) ;\n" +
             "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.RootInterface$InnerIface -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=InputStream, formalParams=(), text=\n" +
-            "\t\treturn new FileInputStream ( \"\" ) ;\n" +
+            "\t\treturn new java.io.FileInputStream ( \"\" ) ;\n" +
             "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.RootInterface$InnerIface$InnerInnerIface -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=OutputStream, formalParams=(), text=\n" +
-            "\t\treturn new FileOutputStream ( \"\" ) ;\n" +
+            "\t\treturn new java.io.FileOutputStream ( \"\" ) ;\n" +
             "\t}\n" +
             "}\n";
     assertEquals(expected, actual);
@@ -164,43 +167,43 @@ public void interfaceTypesAreRecognizedFully() throws Exception {
 
   @Test
   public void typesCombinationsAreRecognizedFully() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/TypesCombination.java";
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/TypesCombination.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     System.out.println(actual);
-    String expected = "ru.ftc.upc.testing.dropper.lang.droplets.SiblingClass -> {\n" +
+    String expected = "ru.ftc.upc.testing.dropper.lang.samples.TypesCombination -> {\n" +
+            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=\n" +
+            "\t\tSystem . console ( ) ;\n" +
+            "\t}\n" +
+            "}\n" +
+            "ru.ftc.upc.testing.dropper.lang.samples.TypesCombination$InnerInterface -> {\n" +
+            "\tTargetMethod{name='innerMethod', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
+            "}\n" +
+            "ru.ftc.upc.testing.dropper.lang.samples.TypesCombination$InnerInterface$InnerInnerClass -> {\n" +
+            "\tTargetMethod{name='innerInnerMethod', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
+            "}\n" +
+            "ru.ftc.upc.testing.dropper.lang.samples.TypesCombination$InnerInterface$InnerInnerClass$InnerInnerInnerEnum -> {\n" +
+            "\tTargetMethod{name='doSomething', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
+            "}\n" +
+            "ru.ftc.upc.testing.dropper.lang.samples.SiblingClass -> {\n" +
             "\tTargetMethod{name='method', cutpoint=INSTEAD, resultType=double, formalParams=(), text=\n" +
             "\t\treturn Math . random ( ) ;\n" +
             "\t}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.droplets.SiblingEnum -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.samples.SiblingEnum -> {\n" +
             "\tTargetMethod{name='SiblingEnum', cutpoint=INSTEAD, resultType=null, formalParams=(), text=(empty)}\n" +
             "\tTargetMethod{name='getMe', cutpoint=INSTEAD, resultType=SiblingEnum, formalParams=(), text=\n" +
             "\t\treturn this ;\n" +
             "\t}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.droplets.SiblingEnum$InnerInterface -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.samples.SiblingEnum$InnerInterface -> {\n" +
             "\tTargetMethod{name='getThatEnum', cutpoint=INSTEAD, resultType=TypesCombination.InnerInterface.InnerInnerClass.InnerInnerInnerEnum, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.droplets.SiblingInterface -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.samples.SiblingInterface -> {\n" +
             "\tTargetMethod{name='method', cutpoint=INSTEAD, resultType=Vector, formalParams=(Vector arg), text=(empty)}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.droplets.SiblingInterface$InnerEnum -> {\n" +
+            "ru.ftc.upc.testing.dropper.lang.samples.SiblingInterface$InnerEnum -> {\n" +
             "\tTargetMethod{name='InnerEnum', cutpoint=INSTEAD, resultType=null, formalParams=(), text=(empty)}\n" +
-            "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.droplets.TypesCombination -> {\n" +
-            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=\n" +
-            "\t\tSystem . console ( ) ;\n" +
-            "\t}\n" +
-            "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.droplets.TypesCombination$InnerInterface -> {\n" +
-            "\tTargetMethod{name='innerMethod', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
-            "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.droplets.TypesCombination$InnerInterface$InnerInnerClass -> {\n" +
-            "\tTargetMethod{name='innerInnerMethod', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
-            "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.droplets.TypesCombination$InnerInterface$InnerInnerClass$InnerInnerInnerEnum -> {\n" +
-            "\tTargetMethod{name='doSomething', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n";
     assertEquals(expected, actual);
   }
@@ -227,7 +230,7 @@ public void importsOnDemandAreNotSupported() throws Exception {
 
   @Test
   public void afterCutpointIsRecognizedFully() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/AfterCutpoint.java";
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/AfterCutpoint.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     Cutpoint actual = targetsMap.entrySet().iterator().next().getValue().getFirst().getCutpoint();
     System.out.printf("Actual cutpoint: %s\n", actual);
@@ -236,13 +239,27 @@ public void afterCutpointIsRecognizedFully() throws Exception {
 
   @Test
   public void defaultCutpointIsAppliedCorrectly() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/droplets/DefaultCutpoint.java";
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DefaultCutpoint.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     Cutpoint actual = targetsMap.entrySet().iterator().next().getValue().getFirst().getCutpoint();
     System.out.printf("Actual cutpoint (default): %s\n", actual);
     assertEquals(Cutpoint.INSTEAD, actual);
   }
 
+  @Test
+  public void typeNamesInMethodBodiesAreResolvedCorrectly() throws Exception {
+    String dropletPath = "src/test/resources/DPClientImpl.java";
+    TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
+    String actual = targetsMap.toString();
+    System.out.println(actual);
+    String expected = "dp.DPClientImpl -> {\n" +
+            "\tTargetMethod{name='currencyRate', cutpoint=INSTEAD, resultType=QuickPay.AnsCurrencyRate, formalParams=(QuickPay.ReqCurrencyRate reqCurrencyRate), text=\n" +
+            "\t\ttry { java.io.FileReader stubReader = new java.io.FileReader ( System . getProperty ( \"user.dir\" ) + java.io.File . separator + \"AnsCurrencyRate.xml\" ) ; javax.xml.bind.Unmarshaller unmarshaller = quickPayJbcDoc . createUnmarshaller ( ) ; dp.models.QuickPay quickPay = ( dp.models.QuickPay ) unmarshaller . unmarshal ( stubReader ) ; log . info ( \"Rates were loaded from file AnsCurrencyRate.xml.\" ) ; stubReader . close ( ) ; return quickPay . getInfoService ( ) . getAnsCurrencyRate ( ) ; } catch ( Exception e ) { log . error ( \"Unable to load rates from file. Falling back to real service.\" , e ) ; dp . models . QuickPay quickPay = dp.models.QuickPay . infoService ( ) ; quickPay . getInfoService ( ) . setReqCurrencyRate ( $1 ) ; quickPay = sendQuickPay ( quickPay , false , false ) ; dp.models.QuickPay . AnsCurrencyRate ans = quickPay . getInfoService ( ) . getAnsCurrencyRate ( ) ; return ans ; }\n" +
+            "\t}\n" +
+            "}\n";
+    assertEquals(expected, actual);
+  }
+
   private DropletAssembler loadDroplet(String dropletPath) throws IOException {
     ANTLRFileStream fileStream = new ANTLRFileStream(dropletPath);
     DroppingJavaLexer lexer = new DroppingJavaLexer(fileStream);
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/AfterCutpoint.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/AfterCutpoint.java
new file mode 100644
index 0000000..9ad18d5
--- /dev/null
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/AfterCutpoint.java
@@ -0,0 +1,26 @@
+package ru.ftc.upc.testing.dropper.lang.samples;
+
+import java.util.Collections;
+import java.util.Observable;
+import java.util.Set;
+
+/**
+ * @author Toparvion
+ */
+public class AfterCutpoint {
+
+  /**
+   * A stub.
+   *
+   * @param path path
+   * @param count  count
+   * @return immutable empty set
+   * @throws Exception never
+   *
+   * @cutpoint AFTER
+   */
+  public Set<Observable> fetchObservables(String path, long count) throws Exception {
+    return Collections.emptySet();
+  }
+
+}
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DefaultCutpoint.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DefaultCutpoint.java
new file mode 100644
index 0000000..6dfc9f9
--- /dev/null
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DefaultCutpoint.java
@@ -0,0 +1,24 @@
+package ru.ftc.upc.testing.dropper.lang.samples;
+
+import java.util.Collections;
+import java.util.Observable;
+import java.util.Set;
+
+/**
+ * @author Toparvion
+ */
+public class DefaultCutpoint {
+
+  /**
+   * A stub.
+   *
+   * @param path path
+   * @param count  count
+   * @return immutable empty set
+   * @throws Exception never
+   */
+  public Set<Observable> fetchObservables(String path, long count) throws Exception {
+    return Collections.emptySet();
+  }
+
+}
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MethodBodies.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MethodBodies.java
new file mode 100644
index 0000000..ae0f7ba
--- /dev/null
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MethodBodies.java
@@ -0,0 +1,26 @@
+package ru.ftc.upc.testing.dropper.lang.samples;
+
+/**
+ * @author Toparvion
+ */
+@SuppressWarnings("unused")
+public class MethodBodies {
+
+  public MethodBodies(String name) {
+    System.out.println("Hello from constructor :) ");
+  }
+
+  public MethodBodies() {
+
+  }
+
+  public boolean method1() {
+    //noinspection RedundantIfStatement
+    if (Math.random() > 0.5d) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+}
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses.java
new file mode 100644
index 0000000..8ecaf39
--- /dev/null
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses.java
@@ -0,0 +1,33 @@
+package ru.ftc.upc.testing.dropper.lang.samples;
+
+/**
+ * @author Toparvion
+ */
+@SuppressWarnings("unused")
+public class MultiNestedClasses {
+
+  int method1() {
+    return 1;
+  }
+
+  class InnerClass1 {
+    int method2() { return 2; }
+
+    int method3() { return 3; }
+  }
+
+  int method4() { return 4; }
+
+  class InnerClass2 {
+    int method5() { return 5; }
+
+    class InnerClass3 {
+      int method6() { return 6; }
+    }
+  }
+
+  class InnerClass4 {}
+
+  int method7() { return 7; }
+
+}
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/RootEnumeration.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/RootEnumeration.java
new file mode 100644
index 0000000..a49fe93
--- /dev/null
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/RootEnumeration.java
@@ -0,0 +1,34 @@
+package ru.ftc.upc.testing.dropper.lang.samples;
+
+/**
+ * @author Toparvion
+ */
+@SuppressWarnings("unused")
+public enum RootEnumeration {
+
+  ONE,
+  TWO,
+  THREE;
+
+  RootEnumeration() {
+    String nothing = "I'm the most enumerated constructor ever!";
+  }
+
+  public static RootEnumeration getByName(String name) {
+    for (RootEnumeration rootEnum : values()) {
+      if (rootEnum.toString().equals(name)) {
+        return rootEnum;
+      }
+    }
+    throw new IllegalArgumentException("Not found: " + name);
+  }
+
+  private enum InnerEnum {
+    INNER_ENUM;
+
+    public boolean isTheSame(Enum<RootEnumeration> e) {
+      return INNER_ENUM.toString().equals(e.toString());
+    }
+  }
+
+}
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/TypesCombination.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/TypesCombination.java
new file mode 100644
index 0000000..e586157
--- /dev/null
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/TypesCombination.java
@@ -0,0 +1,71 @@
+package ru.ftc.upc.testing.dropper.lang.samples;
+
+import java.util.Vector;
+
+/**
+ * @author Toparvion
+ */
+@SuppressWarnings("unused")
+public class TypesCombination {
+  void method1() {
+    System.console();
+  }
+
+  interface InnerInterface {
+    void innerMethod();
+
+    class InnerInnerClass {
+      void innerInnerMethod() { }
+
+      enum InnerInnerInnerEnum {
+        ;
+        static void doSomething() { }
+      }
+
+    }
+
+    @interface InnerAnnotation {
+      int method() default 2;
+    }
+
+  }
+}
+
+@SuppressWarnings("unused")
+class SiblingClass {
+  public double method() {
+    return Math.random();
+  }
+}
+
+
+@SuppressWarnings("unused")
+enum SiblingEnum {
+  ;
+
+  SiblingEnum() {
+  }
+
+  SiblingEnum getMe() {
+    return this;
+  }
+
+  interface InnerInterface {
+    TypesCombination.InnerInterface.InnerInnerClass.InnerInnerInnerEnum getThatEnum();
+  }
+
+  @interface InnerAnnotation { }
+}
+
+@SuppressWarnings("unused")
+interface SiblingInterface {
+  Vector<Object> method(Vector<String> arg);
+
+  enum InnerEnum {
+    ;
+
+    InnerEnum() { }
+  }
+}
+
+
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java
new file mode 100644
index 0000000..59293e3
--- /dev/null
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java
@@ -0,0 +1,53 @@
+package ru.ftc.upc.testing.dropper.lang.samples;
+
+import java.io.BufferedInputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import java.util.*;
+
+/**
+ * @author Toparvion
+ */
+@SuppressWarnings("unused")
+public class VariousMethodHeaders {
+
+  public VariousMethodHeaders() { }
+
+  public VariousMethodHeaders(Stack<Observer> param1) { }
+
+  VariousMethodHeaders(float arg) { }
+
+  static class InnerClass {
+    public InnerClass(Deque<Integer> arg) { }
+  }
+
+  void method1() { }
+
+  void method2(int a) { }
+
+  void method3(Map<String, Object> map) { }
+
+  void method4(List... xs) { }
+
+  void method5(UUID u1, Date... d2) { }
+
+  void method6(double d1, double d2) { }
+
+  double method7() {
+    return Math.random();
+  }
+
+  Set<Currency> method8(EventObject eo) {
+    return Collections.emptySet();
+  }
+
+  @SuppressWarnings("unchecked")
+  private <T extends InputStream> T method9(T source, boolean flag)
+          throws FileNotFoundException {
+    return (T) new BufferedInputStream(source);
+  }
+
+  protected Map.Entry<Long, String> method10(Map.Entry<Double, Integer> arg) {
+    return new AbstractMap.SimpleEntry<Long, String>(23L, "");
+  }
+}
diff --git a/src/test/resources/DPClientImpl.java b/src/test/resources/DPClientImpl.java
new file mode 100644
index 0000000..9d58806
--- /dev/null
+++ b/src/test/resources/DPClientImpl.java
@@ -0,0 +1,40 @@
+package dp;
+
+import javax.xml.bind.Unmarshaller;
+import java.io.File;
+import java.io.FileReader;
+import dp.models.QuickPay;
+
+/**
+ * @author Toparvion
+ */
+public class DPClientImpl {
+
+  /**
+   * Some description.
+   * @param reqCurrencyRate
+   * @return current exchange rate
+   *
+   * @cutpoint INSTEAD
+   */
+  public QuickPay.AnsCurrencyRate currencyRate(QuickPay.ReqCurrencyRate reqCurrencyRate) {
+    try {
+      FileReader stubReader = new FileReader(System.getProperty("user.dir")
+              + File.separator + "AnsCurrencyRate.xml");
+      Unmarshaller unmarshaller = quickPayJbcDoc.createUnmarshaller();
+      QuickPay quickPay = (QuickPay) unmarshaller.unmarshal(stubReader);
+      log.info("Rates were loaded from file AnsCurrencyRate.xml.");
+      stubReader.close();
+      // int someQuickPayContainingId = 1;
+      return quickPay.getInfoService().getAnsCurrencyRate();
+
+    } catch (Exception e) {
+      log.error("Unable to load rates from file. Falling back to real service.", e);
+      dp.models.QuickPay quickPay = QuickPay.infoService();
+      quickPay.getInfoService().setReqCurrencyRate($1);
+      quickPay = sendQuickPay(quickPay, false, false);
+      QuickPay.AnsCurrencyRate ans = quickPay.getInfoService().getAnsCurrencyRate();
+      return ans;
+    }
+  }
+}
diff --git a/src/test/resources/FaultyImports.java b/src/test/resources/FaultyImports.java
index 358f7ad..4cab3aa 100644
--- a/src/test/resources/FaultyImports.java
+++ b/src/test/resources/FaultyImports.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang.droplets;
+package ru.ftc.upc.testing.dropper.lang.samples;
 
 import java.util.Currency;
 import Object;
diff --git a/src/test/resources/FaultyTypesCombination.java b/src/test/resources/FaultyTypesCombination.java
index 1dfc8dd..437a4a5 100644
--- a/src/test/resources/FaultyTypesCombination.java
+++ b/src/test/resources/FaultyTypesCombination.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang.droplets;
+package ru.ftc.upc.testing.dropper.lang.samples;
 
 import java.util.Vector;
 
diff --git a/src/test/resources/Imports.java b/src/test/resources/Imports.java
index 2126b00..8b64ada 100644
--- a/src/test/resources/Imports.java
+++ b/src/test/resources/Imports.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang.droplets;
+package ru.ftc.upc.testing.dropper.lang.samples;
 
 import java.util.Currency;
 import Object;                  // must be ignored by assembler

From cadbf80e4d6cc8f062cfadf7daa4dde1ce1571d6 Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Sat, 4 Jun 2016 00:28:57 +0600
Subject: [PATCH 11/22] UPCSEC-0000 Implemented resolving simple type names
 into fully qualified equivalents among methods' results and parameters

---
 .../dropper/lang/DropletAssembler.java        | 31 ++++++++++++-
 .../dropper/lang/DropletAssemblerTest.java    | 44 ++++++++++++-------
 .../NestedTypesAmongMethodArguments.java      | 16 +++++++
 .../lang/samples/VariousMethodHeaders.java    | 16 ++++---
 4 files changed, 85 insertions(+), 22 deletions(-)
 create mode 100644 src/test/java/ru/ftc/upc/testing/dropper/lang/samples/NestedTypesAmongMethodArguments.java

diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
index 1e392f7..a4295c1 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
@@ -136,6 +136,9 @@ public void enterMethodHeader(DroppingJavaParser.MethodHeaderContext ctx) {
     // store method's result type name
     DroppingJavaParser.ResultContext result = ctx.result();
     String resultType = getPureTypeName(result);
+    if (!"void".equals(resultType)) {           // avoid excess work
+      resultType = resolveMethodArgumentType(resultType);
+    }
     method.setResultType(resultType);
 
     // it's time to store method parameters, if any
@@ -168,13 +171,14 @@ public void enterBlockStatements(DroppingJavaParser.BlockStatementsContext ctx)
    */
   private void storeMethodParams(TargetMethod method, DroppingJavaParser.FormalParameterListContext anyParams) {
     if (anyParams == null) return;
-    String paramType;
+    String paramType;         // for the sake of brevity we use term 'paramType' instead of 'paramTypeName'
     String paramName;
     // first we check for any normal formal params
     DroppingJavaParser.FormalParametersContext formalParams = anyParams.formalParameters();
     if (formalParams != null) {
       for (DroppingJavaParser.FormalParameterContext param : formalParams.formalParameter()) {
         paramType = getPureTypeName(param.unannType());
+        paramType = resolveMethodArgumentType(paramType);
         paramName = param.variableDeclaratorId().Identifier().getText();
         method.getFormalParams().add(new Argument(paramType, paramName));
       }
@@ -190,10 +194,35 @@ private void storeMethodParams(TargetMethod method, DroppingJavaParser.FormalPar
         paramType = getPureTypeName(lastFormalParam.unannType());
         paramName = lastFormalParam.variableDeclaratorId().Identifier().getText();
       }
+      paramType = resolveMethodArgumentType(paramType);
       method.getFormalParams().add(new Argument(paramType, paramName));
     }
   }
 
+  /**
+   * Applies 2 modifications to given type name: (1) prepends it with package path according to
+   * {@link #importsMap} of this droplet; (2) converts it to {@link ClassLoader binary} name format, i.e. replaces
+   * dots in non-package part with dollar signs (e.g. turns {@code Map.Entry} to {@code Map$Entry}).
+   * @param argumentType  original parameter or result type name as it was extracted from droplet parse tree
+   * @return resolved name (may appear the same)
+   */
+  private String resolveMethodArgumentType(String argumentType) {
+    if (argumentType == null || argumentType.isEmpty())
+      return argumentType;
+    // first we need to cut off any references to inner types
+    String[] typeEntries = argumentType.split("\\.");
+    String outerType = typeEntries[0];
+    // during resolving we must make the type name binary compatible (see java.lang.ClassLoader#name)
+    String binaryName = typeEntries.length > 1
+            ? argumentType.replaceAll("\\.", Matcher.quoteReplacement("$"))
+            : argumentType;
+    // then we can search for corresponding import
+    String fqPrefix = importsMap.get(outerType);
+    return (fqPrefix == null)
+            ? binaryName
+            : (fqPrefix + "." + binaryName);
+  }
+
   /**
    * Finds the latest entry of fully-qualified type name, e.g. {@code Set} from {@code java.util.Set<String>}.
    * @param typeCtx type rule context to extract the name from
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
index e5ee833..f820a19 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
@@ -68,29 +68,26 @@ public void methodHeadersAreRecognizedFully() throws Exception {
     System.out.println(actual);
     String expected = "ru.ftc.upc.testing.dropper.lang.samples.VariousMethodHeaders -> {\n" +
             "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(), text=(empty)}\n" +
-            "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(Stack param1), text=(empty)}\n" +
+            "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(java.util.Stack param1), text=(empty)}\n" +
             "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(float arg), text=(empty)}\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "\tTargetMethod{name='method2', cutpoint=INSTEAD, resultType=void, formalParams=(int a), text=(empty)}\n" +
-            "\tTargetMethod{name='method3', cutpoint=INSTEAD, resultType=void, formalParams=(Map map), text=(empty)}\n" +
-            "\tTargetMethod{name='method4', cutpoint=INSTEAD, resultType=void, formalParams=(List xs), text=(empty)}\n" +
-            "\tTargetMethod{name='method5', cutpoint=INSTEAD, resultType=void, formalParams=(UUID u1, Date d2), text=(empty)}\n" +
+            "\tTargetMethod{name='method3', cutpoint=INSTEAD, resultType=void, formalParams=(java.util.Map map), text=(empty)}\n" +
+            "\tTargetMethod{name='method4', cutpoint=INSTEAD, resultType=void, formalParams=(java.util.List xs), text=(empty)}\n" +
+            "\tTargetMethod{name='method5', cutpoint=INSTEAD, resultType=void, formalParams=(java.util.UUID u1, java.util.Date d2), text=(empty)}\n" +
             "\tTargetMethod{name='method6', cutpoint=INSTEAD, resultType=void, formalParams=(double d1, double d2), text=(empty)}\n" +
             "\tTargetMethod{name='method7', cutpoint=INSTEAD, resultType=double, formalParams=(), text=\n" +
             "\t\treturn Math . random ( ) ;\n" +
             "\t}\n" +
-            "\tTargetMethod{name='method8', cutpoint=INSTEAD, resultType=Set, formalParams=(EventObject eo), text=\n" +
+            "\tTargetMethod{name='method8', cutpoint=INSTEAD, resultType=java.util.Set, formalParams=(java.util.EventObject eo), text=\n" +
             "\t\treturn java.util.Collections . emptySet ( ) ;\n" +
             "\t}\n" +
             "\tTargetMethod{name='method9', cutpoint=INSTEAD, resultType=T, formalParams=(T source, boolean flag), text=\n" +
             "\t\treturn ( T ) new java.io.BufferedInputStream ( source ) ;\n" +
             "\t}\n" +
-            "\tTargetMethod{name='method10', cutpoint=INSTEAD, resultType=Map.Entry, formalParams=(Map.Entry arg), text=\n" +
-            "\t\treturn new java.util.AbstractMap . SimpleEntry < Long , String > ( 23L , \"\" ) ;\n" +
-            "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.samples.VariousMethodHeaders$InnerClass -> {\n" +
-            "\tTargetMethod{name='InnerClass', cutpoint=INSTEAD, resultType=null, formalParams=(Deque arg), text=(empty)}\n" +
+            "\tTargetMethod{name='InnerClass', cutpoint=INSTEAD, resultType=null, formalParams=(java.util.Deque arg), text=(empty)}\n" +
             "}\n";
     assertEquals(expected, actual);
   }
@@ -144,21 +141,21 @@ public void interfaceTypesAreRecognizedFully() throws Exception {
     String expected = "ru.ftc.upc.testing.dropper.lang.RootInterface -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "\tTargetMethod{name='method2', cutpoint=INSTEAD, resultType=boolean, formalParams=(int two), text=(empty)}\n" +
-            "\tTargetMethod{name='method3', cutpoint=INSTEAD, resultType=RootInterface, formalParams=(Set longs), text=(empty)}\n" +
+            "\tTargetMethod{name='method3', cutpoint=INSTEAD, resultType=RootInterface, formalParams=(java.util.Set longs), text=(empty)}\n" +
             "\tTargetMethod{name='method5', cutpoint=INSTEAD, resultType=double, formalParams=(Float param1), text=\n" +
             "\t\treturn Math . random ( ) ;\n" +
             "\t}\n" +
-            "\tTargetMethod{name='newObservable', cutpoint=INSTEAD, resultType=Observable, formalParams=(List lof), text=\n" +
+            "\tTargetMethod{name='newObservable', cutpoint=INSTEAD, resultType=java.util.Observable, formalParams=(java.util.List lof), text=\n" +
             "\t\treturn new java.util.Observable ( ) ;\n" +
             "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.RootInterface$InnerIface -> {\n" +
-            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=InputStream, formalParams=(), text=\n" +
+            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=java.io.InputStream, formalParams=(), text=\n" +
             "\t\treturn new java.io.FileInputStream ( \"\" ) ;\n" +
             "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.RootInterface$InnerIface$InnerInnerIface -> {\n" +
-            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=OutputStream, formalParams=(), text=\n" +
+            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=java.io.OutputStream, formalParams=(), text=\n" +
             "\t\treturn new java.io.FileOutputStream ( \"\" ) ;\n" +
             "\t}\n" +
             "}\n";
@@ -197,10 +194,10 @@ public void typesCombinationsAreRecognizedFully() throws Exception {
             "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.samples.SiblingEnum$InnerInterface -> {\n" +
-            "\tTargetMethod{name='getThatEnum', cutpoint=INSTEAD, resultType=TypesCombination.InnerInterface.InnerInnerClass.InnerInnerInnerEnum, formalParams=(), text=(empty)}\n" +
+            "\tTargetMethod{name='getThatEnum', cutpoint=INSTEAD, resultType=TypesCombination$InnerInterface$InnerInnerClass$InnerInnerInnerEnum, formalParams=(), text=(empty)}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.samples.SiblingInterface -> {\n" +
-            "\tTargetMethod{name='method', cutpoint=INSTEAD, resultType=Vector, formalParams=(Vector arg), text=(empty)}\n" +
+            "\tTargetMethod{name='method', cutpoint=INSTEAD, resultType=java.util.Vector, formalParams=(java.util.Vector arg), text=(empty)}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.samples.SiblingInterface$InnerEnum -> {\n" +
             "\tTargetMethod{name='InnerEnum', cutpoint=INSTEAD, resultType=null, formalParams=(), text=(empty)}\n" +
@@ -253,13 +250,28 @@ public void typeNamesInMethodBodiesAreResolvedCorrectly() throws Exception {
     String actual = targetsMap.toString();
     System.out.println(actual);
     String expected = "dp.DPClientImpl -> {\n" +
-            "\tTargetMethod{name='currencyRate', cutpoint=INSTEAD, resultType=QuickPay.AnsCurrencyRate, formalParams=(QuickPay.ReqCurrencyRate reqCurrencyRate), text=\n" +
+            "\tTargetMethod{name='currencyRate', cutpoint=INSTEAD, resultType=dp.models.QuickPay$AnsCurrencyRate, formalParams=(dp.models.QuickPay$ReqCurrencyRate reqCurrencyRate), text=\n" +
             "\t\ttry { java.io.FileReader stubReader = new java.io.FileReader ( System . getProperty ( \"user.dir\" ) + java.io.File . separator + \"AnsCurrencyRate.xml\" ) ; javax.xml.bind.Unmarshaller unmarshaller = quickPayJbcDoc . createUnmarshaller ( ) ; dp.models.QuickPay quickPay = ( dp.models.QuickPay ) unmarshaller . unmarshal ( stubReader ) ; log . info ( \"Rates were loaded from file AnsCurrencyRate.xml.\" ) ; stubReader . close ( ) ; return quickPay . getInfoService ( ) . getAnsCurrencyRate ( ) ; } catch ( Exception e ) { log . error ( \"Unable to load rates from file. Falling back to real service.\" , e ) ; dp . models . QuickPay quickPay = dp.models.QuickPay . infoService ( ) ; quickPay . getInfoService ( ) . setReqCurrencyRate ( $1 ) ; quickPay = sendQuickPay ( quickPay , false , false ) ; dp.models.QuickPay . AnsCurrencyRate ans = quickPay . getInfoService ( ) . getAnsCurrencyRate ( ) ; return ans ; }\n" +
             "\t}\n" +
             "}\n";
     assertEquals(expected, actual);
   }
 
+  @Test
+  public void methodArgumentTypesAreResolvedCorrectly() throws Exception {
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/NestedTypesAmongMethodArguments.java";
+    TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
+    String actual = targetsMap.toString();
+    System.out.println(actual);
+
+    String expected = "ru.ftc.upc.testing.dropper.lang.samples.NestedTypesAmongMethodArguments -> {\n" +
+            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=java.util.Map$Entry, formalParams=(java.security.KeyStore$SecretKeyEntry arg), text=\n" +
+            "\t\treturn new java.util.AbstractMap . SimpleEntry < Long , String > ( 23L , \"\" ) ;\n" +
+            "\t}\n" +
+            "}\n";
+    assertEquals(expected, actual);
+  }
+
   private DropletAssembler loadDroplet(String dropletPath) throws IOException {
     ANTLRFileStream fileStream = new ANTLRFileStream(dropletPath);
     DroppingJavaLexer lexer = new DroppingJavaLexer(fileStream);
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/NestedTypesAmongMethodArguments.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/NestedTypesAmongMethodArguments.java
new file mode 100644
index 0000000..3bbe2e0
--- /dev/null
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/NestedTypesAmongMethodArguments.java
@@ -0,0 +1,16 @@
+package ru.ftc.upc.testing.dropper.lang.samples;
+
+import java.security.KeyStore;
+import java.util.AbstractMap;
+import java.util.Map;
+
+/**
+ * @author Toparvion
+ */
+@SuppressWarnings("unused")
+public class NestedTypesAmongMethodArguments {
+
+  protected Map.Entry<Long, String> method1(KeyStore.SecretKeyEntry arg) {
+    return new AbstractMap.SimpleEntry<Long, String>(23L, "");
+  }
+}
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java
index 59293e3..6ccac79 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java
@@ -3,7 +3,17 @@
 import java.io.BufferedInputStream;
 import java.io.FileNotFoundException;
 import java.io.InputStream;
-import java.util.*;
+import java.util.Collections;
+import java.util.Currency;
+import java.util.Date;
+import java.util.Deque;
+import java.util.EventObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Observer;
+import java.util.Set;
+import java.util.Stack;
+import java.util.UUID;
 
 /**
  * @author Toparvion
@@ -46,8 +56,4 @@ private <T extends InputStream> T method9(T source, boolean flag)
           throws FileNotFoundException {
     return (T) new BufferedInputStream(source);
   }
-
-  protected Map.Entry<Long, String> method10(Map.Entry<Double, Integer> arg) {
-    return new AbstractMap.SimpleEntry<Long, String>(23L, "");
-  }
 }

From fb2a96b11500845c1fb2cf761385d8c22cc1eee0 Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Sat, 4 Jun 2016 13:36:35 +0600
Subject: [PATCH 12/22] UPCSEC-0000 Implemented obfuscation of formal
 parameters references within methods' bodies

---
 .../dropper/lang/DropletAssembler.java        | 49 ++++++++++++++++---
 .../dropper/lang/DropletAssemblerTest.java    | 26 +++++++---
 src/test/resources/DPClientImpl2.java         | 40 +++++++++++++++
 3 files changed, 101 insertions(+), 14 deletions(-)
 create mode 100644 src/test/resources/DPClientImpl2.java

diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
index a4295c1..31f7419 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
@@ -14,6 +14,8 @@
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import static java.util.regex.Matcher.quoteReplacement;
+
 /**
  * The main class responsible for extracting valuable data from droplet files. Built upon ANTLR parse tree event
  * listener.
@@ -159,6 +161,7 @@ public void enterBlockStatements(DroppingJavaParser.BlockStatementsContext ctx)
     String bodyText = visitor.visit(ctx);
     bodyText = makeTypeNamesFullyQualified(bodyText);
     TargetMethod currentMethod = targetsMap.get(composeCurrentKey()).getLast();
+    bodyText = obfuscateParameterReferences(bodyText, currentMethod.getFormalParams());
     currentMethod.setText(bodyText);
   }
   //endregion
@@ -214,7 +217,7 @@ private String resolveMethodArgumentType(String argumentType) {
     String outerType = typeEntries[0];
     // during resolving we must make the type name binary compatible (see java.lang.ClassLoader#name)
     String binaryName = typeEntries.length > 1
-            ? argumentType.replaceAll("\\.", Matcher.quoteReplacement("$"))
+            ? argumentType.replaceAll("\\.", quoteReplacement("$"))
             : argumentType;
     // then we can search for corresponding import
     String fqPrefix = importsMap.get(outerType);
@@ -313,7 +316,8 @@ private String makeTypeNamesFullyQualified(String bodyText) {
       Matcher matcher = pattern.matcher(processedText);
       StringBuffer sb = new StringBuffer(bodyText.length()+30);
       while (matcher.find()) {
-        if (!isNameAlreadyQualified(processedText, matcher.start(2), fqName)) {
+        // by the following check we exclude references to already qualified types (both fully and inner)
+        if (!isNameAlreadyQualified(processedText, matcher.start())) {
           matcher.appendReplacement(sb, "$1" + fqName + "$2");
         }
       }
@@ -324,13 +328,42 @@ private String makeTypeNamesFullyQualified(String bodyText) {
   }
 
   /**
-   * Detects whether type name on position denoted by {@code typeNameEndPosition} is fully qualified.
+   * Detects whether the type name on position denoted by {@code typeNameStartPosition} is qualified in any way. This
+   * includes both cases when the name is fully qualified (e.g. {@code java.util.Map}) and when it is bounded within a
+   * containing type (e.g. {@code KeyStore.Builder}). In the latter case the resolving will be applied to containing
+   * type ({@code KeyStore}), not the contained one ({@code Builder}).
+   */
+  private boolean isNameAlreadyQualified(String wholeText, int typeNameStartPosition) {
+    int precedingSymbolStartPosition = Math.max(0, (typeNameStartPosition-2));
+    return ". ".equals(wholeText.substring(precedingSymbolStartPosition, typeNameStartPosition));
+  }
+
+  /**
+   * Replaces formal parameters references with symbolic equivalents according to Javassist notation (i.e. replaces
+   * explicit names with ordinal links, for example {@code callMethod(someParam)} with {@code callMethod($1)}).
+   * @param bodyText original method's body text
+   * @param formalParams  list of method's formal parameters
+   * @return reformatted body text (may be the same as original)
    */
-  private boolean isNameAlreadyQualified(String wholeText, int typeNameEndPosition, String typeFqName) {
-    String sparseFqName = typeFqName.replaceAll("\\.", " . ");
-    int precursorStartPosition = Math.max(0, (typeNameEndPosition - sparseFqName.length()));
-    String precursor = wholeText.substring(precursorStartPosition, typeNameEndPosition);
-    return sparseFqName.equals(precursor);
+  private String obfuscateParameterReferences(String bodyText, List<Argument> formalParams) {
+    if (bodyText == null || bodyText.isEmpty())
+      return bodyText;
+    String processedText = bodyText;
+    for (int i = 1; i <= formalParams.size(); i++) {
+      String paramName = formalParams.get(i-1).getName();
+      Pattern pattern = Pattern.compile("(\\b)" + paramName + "(\\b)");
+      Matcher matcher = pattern.matcher(processedText);
+      StringBuffer sb = new StringBuffer(bodyText.length());
+      while (matcher.find()) {
+        // by the following check we exclude ambiguous references to some field with a name equal to current param
+        if (!isNameAlreadyQualified(bodyText, matcher.start())) {
+          matcher.appendReplacement(sb, "$1" + quoteReplacement("$"+i) + "$2");
+        }
+      }
+      matcher.appendTail(sb);
+      processedText = sb.toString();
+    }
+    return processedText;
   }
   //endregion
 
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
index f820a19..673bde7 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
@@ -83,7 +83,7 @@ public void methodHeadersAreRecognizedFully() throws Exception {
             "\t\treturn java.util.Collections . emptySet ( ) ;\n" +
             "\t}\n" +
             "\tTargetMethod{name='method9', cutpoint=INSTEAD, resultType=T, formalParams=(T source, boolean flag), text=\n" +
-            "\t\treturn ( T ) new java.io.BufferedInputStream ( source ) ;\n" +
+            "\t\treturn ( T ) new java.io.BufferedInputStream ( $1 ) ;\n" +
             "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.samples.VariousMethodHeaders$InnerClass -> {\n" +
@@ -121,12 +121,12 @@ public void enumTypesAreRecognizedFully() throws Exception {
             "\t\tString nothing = \"I'm the most enumerated constructor ever!\" ;\n" +
             "\t}\n" +
             "\tTargetMethod{name='getByName', cutpoint=INSTEAD, resultType=RootEnumeration, formalParams=(String name), text=\n" +
-            "\t\tfor ( RootEnumeration rootEnum : values ( ) ) { if ( rootEnum . toString ( ) . equals ( name ) ) { return rootEnum ; } } throw new IllegalArgumentException ( \"Not found: \" + name ) ;\n" +
+            "\t\tfor ( RootEnumeration rootEnum : values ( ) ) { if ( rootEnum . toString ( ) . equals ( $1 ) ) { return rootEnum ; } } throw new IllegalArgumentException ( \"Not found: \" + $1 ) ;\n" +
             "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.samples.RootEnumeration$InnerEnum -> {\n" +
             "\tTargetMethod{name='isTheSame', cutpoint=INSTEAD, resultType=boolean, formalParams=(Enum e), text=\n" +
-            "\t\treturn INNER_ENUM . toString ( ) . equals ( e . toString ( ) ) ;\n" +
+            "\t\treturn INNER_ENUM . toString ( ) . equals ( $1 . toString ( ) ) ;\n" +
             "\t}\n" +
             "}\n";
     assertEquals(expected, actual);
@@ -272,6 +272,20 @@ public void methodArgumentTypesAreResolvedCorrectly() throws Exception {
     assertEquals(expected, actual);
   }
 
+  @Test
+  public void formalParamReferencesAreObfuscatedCorrectly() throws Exception {
+    String dropletPath = "src/test/resources/DPClientImpl2.java";
+    TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
+    String actual = targetsMap.toString();
+    System.out.println(actual);
+    String expected = "dp.DPClientImpl2 -> {\n" +
+            "\tTargetMethod{name='fetchTransferStatus', cutpoint=INSTEAD, resultType=String, formalParams=(String oID, boolean needFlag), text=\n" +
+            "\t\tString statusStr = null ; try { java.util.Properties stub = new java.util.Properties ( ) ; stub . load ( new java.io.FileReader ( System . getProperty ( \"user.dir\" ) + java.io.File . separator + \"dp-edit-mock.properties\" ) ) ; statusStr = stub . getProperty ( $1 ) ; if ( statusStr != null ) { statusStr = statusStr . trim ( ) ; log . warn ( \"For STRoID={} transfer status '{}' was taken from mock.\" , $1 , statusStr ) ; } } catch ( java.io.IOException e ) { log . error ( \"Failed to load mocked transfer edit statuses.\" , e ) ; } if ( statusStr == null ) { dp.models.QuickPay quickPay = dp.models.QuickPay . infoService ( ) ; dp.models.ReqTransferSearch req = new dp.models.ReqTransferSearch ( ) ; req . setOID ( getReserve ( ) . oID ) ; quickPay . getInfoService ( ) . setReqTransferSearch ( req ) ; quickPay = sendQuickPay ( quickPay , false , $2 ) ; statusStr = quickPay . getInfoService ( ) . getAnsTransferSearch ( ) . getTransferStatus ( ) ; } return statusStr ;\n" +
+            "\t}\n" +
+            "}\n";
+    assertEquals(expected, actual);
+  }
+
   private DropletAssembler loadDroplet(String dropletPath) throws IOException {
     ANTLRFileStream fileStream = new ANTLRFileStream(dropletPath);
     DroppingJavaLexer lexer = new DroppingJavaLexer(fileStream);
@@ -279,11 +293,11 @@ private DropletAssembler loadDroplet(String dropletPath) throws IOException {
     DroppingJavaParser parser = new DroppingJavaParser(tokenStream);
     ParseTree tree = parser.compilationUnit();
 
-    DropletAssembler listener = new DropletAssembler(tokenStream);
+    DropletAssembler assembler = new DropletAssembler(tokenStream);
     ParseTreeWalker walker = new ParseTreeWalker();
-    walker.walk(listener, tree);
+    walker.walk(assembler, tree);
 
-    return listener;
+    return assembler;
   }
 
   private String map2Str(Map<String, String> map) {
diff --git a/src/test/resources/DPClientImpl2.java b/src/test/resources/DPClientImpl2.java
new file mode 100644
index 0000000..088f72a
--- /dev/null
+++ b/src/test/resources/DPClientImpl2.java
@@ -0,0 +1,40 @@
+package dp;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Properties;
+
+import dp.models.QuickPay;
+import dp.models.ReqTransferSearch;
+
+public class DPClientImpl2 {
+
+  @Override
+  public String fetchTransferStatus(String oID, boolean needFlag) throws Exception {
+    String statusStr = null;
+    try {
+      Properties stub = new Properties();
+      stub.load(new FileReader(System.getProperty("user.dir")
+              + File.separator + "dp-edit-mock.properties"));
+      statusStr = stub.getProperty(oID);
+      if (statusStr != null) {
+        statusStr = statusStr.trim();
+        log.warn("For STRoID={} transfer status '{}' was taken from mock.", oID, statusStr);
+      }
+    } catch (IOException e) {
+      log.error("Failed to load mocked transfer edit statuses.", e);
+    }
+    if (statusStr == null) {
+      QuickPay quickPay = QuickPay.infoService();
+      ReqTransferSearch req = new ReqTransferSearch();
+      req.setOID(getReserve().oID);
+      quickPay.getInfoService().setReqTransferSearch(req);
+      quickPay = sendQuickPay(quickPay, false, needFlag);
+      statusStr = quickPay.getInfoService().getAnsTransferSearch().getTransferStatus();
+    }
+    return statusStr;
+  }
+
+
+}
\ No newline at end of file

From bab02ca4322b32d19e0b475be90082d454b651a8 Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Sat, 4 Jun 2016 14:45:48 +0600
Subject: [PATCH 13/22] UPCSEC-0000 Implemented omission of droplet class
 suffixes. Added checking for duplicate target method definition.

---
 .../dropper/lang/DropletAssembler.java        | 15 ++++----
 .../upc/testing/dropper/model/TargetsMap.java | 35 ++++++++++++++++---
 .../dropper/lang/DropletAssemblerTest.java    | 33 ++++++++++++++++-
 .../lang/samples/ClassWithSuffixDroplet.java  | 23 ++++++++++++
 .../samples/DuplicatedMethodsDetection.java   | 20 +++++++++++
 src/test/resources/DPClientImpl2.java         |  2 +-
 6 files changed, 116 insertions(+), 12 deletions(-)
 create mode 100644 src/test/java/ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffixDroplet.java
 create mode 100644 src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DuplicatedMethodsDetection.java

diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
index 31f7419..a2d98f4 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
@@ -117,23 +117,22 @@ public void exitNormalInterfaceDeclaration(DroppingJavaParser.NormalInterfaceDec
    */
   @Override
   public void enterConstructorDeclarator(DroppingJavaParser.ConstructorDeclaratorContext ctx) {
-    // as we consider constructor as methods, let's firstly save it
-    String key = composeCurrentKey();
+    // as we consider constructor as methods, let's firstly initialize it
     TargetMethod method = new TargetMethod(ctx.simpleTypeName().getText());
-    targetsMap.put(key, method);
 
     // There is no result type for constructors so we pass setting Method's result field. Proceed to formal parameters.
     DroppingJavaParser.FormalParameterListContext anyParams = ctx.formalParameterList();
     storeMethodParams(method, anyParams);
+
+    // now that we know everything about the method we can store into targets map
+    targetsMap.put(composeCurrentKey(), method);
   }
 
   @Override
   public void enterMethodHeader(DroppingJavaParser.MethodHeaderContext ctx) {
-    // first of all let's save this method itself
-    String key = composeCurrentKey();
+    // first of all let's initialize this method itself
     DroppingJavaParser.MethodDeclaratorContext declarator = ctx.methodDeclarator();
     TargetMethod method = new TargetMethod(declarator.Identifier().getText());
-    targetsMap.put(key, method);
 
     // store method's result type name
     DroppingJavaParser.ResultContext result = ctx.result();
@@ -152,6 +151,9 @@ public void enterMethodHeader(DroppingJavaParser.MethodHeaderContext ctx) {
     if (cutpointStr != null) {
       method.setCutpoint(Cutpoint.valueOf(cutpointStr.toUpperCase()));
     }
+
+    // finally we can store the method in targets map
+    targetsMap.put(composeCurrentKey(), method);
   }
 
   @Override
@@ -292,6 +294,7 @@ private String composeCurrentKey() {
       } else {
         first = false;
       }
+      className = className.replaceFirst("(?i)_?Droplet$", "");     // todo allow customizing through settings
       sb.append(className);
     }
 
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java
index fa48afa..e9516fd 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java
@@ -1,9 +1,6 @@
 package ru.ftc.upc.testing.dropper.model;
 
-import java.util.Deque;
-import java.util.LinkedHashMap;
-import java.util.LinkedList;
-import java.util.Map;
+import java.util.*;
 
 /**
  * @author Toparvion
@@ -18,10 +15,40 @@ public void put(String key, TargetMethod method) {
       this.put(key, methods);
 
     } else {
+      checkForDuplicate(methods, method, key);      // throws IllegalArgumentException if a duplicate found
       methods.addLast(method);
     }
   }
 
+  private void checkForDuplicate(Deque<TargetMethod> methods, TargetMethod newMethod, String classFqName)
+          throws IllegalArgumentException {
+    for (TargetMethod oldMethod : methods) {
+      if (oldMethod.getName().equals(newMethod.getName())
+              && oldMethod.getCutpoint().equals(newMethod.getCutpoint())
+              && areParameterListsEqual(oldMethod, newMethod)) {
+        String message = String.format("Method '%s' of class '%s' is already added for modifying in cutpoint '%s'.",
+                newMethod.getName(), classFqName, newMethod.getCutpoint());
+        throw new IllegalArgumentException(message);
+      }
+    }
+  }
+
+  private boolean areParameterListsEqual(TargetMethod method1, TargetMethod method2) {
+    if (method1.getFormalParams().size() != method2.getFormalParams().size()) {
+      return false;
+    }
+    List<Argument> params1 = method1.getFormalParams();
+    List<Argument> params2 = method2.getFormalParams();
+    for (int i = 0; i < params1.size(); i++) {
+      String type1 = params1.get(i).getType();
+      String type2 = params2.get(i).getType();
+      if (!type1.equals(type2)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   @Override
   public String toString() {
     StringBuilder sb = new StringBuilder();
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
index 673bde7..fddafa2 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
@@ -278,7 +278,7 @@ public void formalParamReferencesAreObfuscatedCorrectly() throws Exception {
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     System.out.println(actual);
-    String expected = "dp.DPClientImpl2 -> {\n" +
+    String expected = "dp.DPClientImpl -> {\n" +
             "\tTargetMethod{name='fetchTransferStatus', cutpoint=INSTEAD, resultType=String, formalParams=(String oID, boolean needFlag), text=\n" +
             "\t\tString statusStr = null ; try { java.util.Properties stub = new java.util.Properties ( ) ; stub . load ( new java.io.FileReader ( System . getProperty ( \"user.dir\" ) + java.io.File . separator + \"dp-edit-mock.properties\" ) ) ; statusStr = stub . getProperty ( $1 ) ; if ( statusStr != null ) { statusStr = statusStr . trim ( ) ; log . warn ( \"For STRoID={} transfer status '{}' was taken from mock.\" , $1 , statusStr ) ; } } catch ( java.io.IOException e ) { log . error ( \"Failed to load mocked transfer edit statuses.\" , e ) ; } if ( statusStr == null ) { dp.models.QuickPay quickPay = dp.models.QuickPay . infoService ( ) ; dp.models.ReqTransferSearch req = new dp.models.ReqTransferSearch ( ) ; req . setOID ( getReserve ( ) . oID ) ; quickPay . getInfoService ( ) . setReqTransferSearch ( req ) ; quickPay = sendQuickPay ( quickPay , false , $2 ) ; statusStr = quickPay . getInfoService ( ) . getAnsTransferSearch ( ) . getTransferStatus ( ) ; } return statusStr ;\n" +
             "\t}\n" +
@@ -286,6 +286,37 @@ public void formalParamReferencesAreObfuscatedCorrectly() throws Exception {
     assertEquals(expected, actual);
   }
 
+  @Test
+  public void dropletSuffixIsOmittedCorrectly() throws Exception {
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffixDroplet.java";
+    TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
+    String actual = targetsMap.toString();
+    System.out.println(actual);
+
+    String expected = "ru.ftc.upc.testing.dropper.lang.samples.ClassWithSuffix -> {\n" +
+            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
+            "}\n" +
+            "ru.ftc.upc.testing.dropper.lang.samples.ClassWithSuffix$InnerClass -> {\n" +
+            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
+            "}\n" +
+            "ru.ftc.upc.testing.dropper.lang.samples.ClassWithSuffix$InnerClass2 -> {\n" +
+            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
+            "}\n" +
+            "ru.ftc.upc.testing.dropper.lang.samples.ClassWithSuffix$InnerClassDropletNotLatest -> {\n" +
+            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
+            "}\n";
+    assertEquals(expected, actual);
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void methodDuplicatesAreDetectedCorrectly() throws Exception {
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DuplicatedMethodsDetection.java";
+    TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
+    String actual = targetsMap.toString();
+    System.out.println(actual);
+
+  }
+
   private DropletAssembler loadDroplet(String dropletPath) throws IOException {
     ANTLRFileStream fileStream = new ANTLRFileStream(dropletPath);
     DroppingJavaLexer lexer = new DroppingJavaLexer(fileStream);
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffixDroplet.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffixDroplet.java
new file mode 100644
index 0000000..c3af137
--- /dev/null
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffixDroplet.java
@@ -0,0 +1,23 @@
+package ru.ftc.upc.testing.dropper.lang.samples;
+
+/**
+ * @author Toparvion
+ */
+@SuppressWarnings("unused")
+public class ClassWithSuffixDroplet {
+
+  void method1() {}
+
+  protected class InnerClass_Droplet {
+    void method1() {}
+  }
+
+  private static class InnerClass2dRoPlEt {
+    void method1() { }
+  }
+
+  class InnerClassDropletNotLatest {
+    void method1() {}
+  }
+
+}
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DuplicatedMethodsDetection.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DuplicatedMethodsDetection.java
new file mode 100644
index 0000000..73251e8
--- /dev/null
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DuplicatedMethodsDetection.java
@@ -0,0 +1,20 @@
+package ru.ftc.upc.testing.dropper.lang.samples;
+
+/**
+ * Target classes may have different names that may be confusing in case several droplets define the same method for
+ * modifying. To address this issue Dropper must check the duplicates itself. This sample contains the problematic
+ * combination of methods.
+ * @author Toparvion
+ */
+@SuppressWarnings("unused")
+public class DuplicatedMethodsDetection {
+
+  class InnerClassDroplet {
+    void method1() {}
+  }
+
+  class InnerClass_Droplet {
+    void method1() {}
+  }
+
+}
diff --git a/src/test/resources/DPClientImpl2.java b/src/test/resources/DPClientImpl2.java
index 088f72a..856402b 100644
--- a/src/test/resources/DPClientImpl2.java
+++ b/src/test/resources/DPClientImpl2.java
@@ -8,7 +8,7 @@
 import dp.models.QuickPay;
 import dp.models.ReqTransferSearch;
 
-public class DPClientImpl2 {
+public class DPClientImpl {
 
   @Override
   public String fetchTransferStatus(String oID, boolean needFlag) throws Exception {

From 6dd828015f0c06410432449af0f92022f3bc2cc4 Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Sat, 4 Jun 2016 23:01:57 +0600
Subject: [PATCH 14/22] UPCSEC-0000 Added checking for double 'droplet' suffix

---
 .../java/ru/ftc/upc/testing/dropper/model/TargetMethod.java  | 5 +++++
 .../ftc/upc/testing/dropper/lang/DropletAssemblerTest.java   | 3 +++
 .../testing/dropper/lang/samples/ClassWithSuffixDroplet.java | 4 ++++
 3 files changed, 12 insertions(+)

diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
index 5ada6f9..8b53184 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
@@ -55,6 +55,11 @@ public void setResultType(String resultType) {
     this.resultType = resultType;
   }
 
+  /**
+   * <em>ATTENTION!</em> This method is actively used in unit tests result checking, therefore its changing may cause
+   * many tests fail.
+   * @return string representation of this target method
+   */
   @Override
   public String toString() {
     return "TargetMethod{" +
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
index fddafa2..f2915a2 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
@@ -304,6 +304,9 @@ public void dropletSuffixIsOmittedCorrectly() throws Exception {
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.samples.ClassWithSuffix$InnerClassDropletNotLatest -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
+            "}\n" +
+            "ru.ftc.upc.testing.dropper.lang.samples.ClassWithSuffix$InnerClassDroplet -> {\n" +
+            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n";
     assertEquals(expected, actual);
   }
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffixDroplet.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffixDroplet.java
index c3af137..e23ce1e 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffixDroplet.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffixDroplet.java
@@ -20,4 +20,8 @@ class InnerClassDropletNotLatest {
     void method1() {}
   }
 
+  class InnerClassDroplet_Droplet {
+    void method1() {}
+  }
+
 }

From 3cf7dfc9c9d1ee57fe2bb7f8ff78f96a6cbd5b64 Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Sun, 5 Jun 2016 15:22:03 +0600
Subject: [PATCH 15/22] UPCSEC-0000 Added DropletChecker utility for checking
 droplet formats. Added checking for parametrized types in method headers.

---
 build.gradle                                  |  3 +-
 .../upc/testing/dropper/DropletChecker.java   | 28 +++++++++
 .../upc/testing/dropper/DropletLoader.java    | 63 +++++++++++++++++++
 .../dropper/lang/DropletAssembler.java        | 33 ++++++++--
 .../lang/GenericTypeSearchVisitor.java        | 27 ++++++++
 .../dropper/lang/UnderlineErrorListener.java  | 46 ++++++++++++++
 .../upc/testing/dropper/model/Droplet.java    |  8 ---
 .../upc/testing/dropper/model/DropletV2.java  | 23 +++++++
 .../upc/testing/dropper/model/TargetsMap.java | 20 ++++++
 .../testing/dropper/DropletLoaderTest.java    | 18 ++++++
 .../dropper/lang/DropletAssemblerTest.java    | 22 ++++++-
 .../dropper/lang/samples/GenericClass.java    | 26 ++++++++
 .../dropper/lang/samples/GenericClass2.java   | 25 ++++++++
 .../lang/samples/VariousMethodHeaders.java    |  8 ---
 14 files changed, 324 insertions(+), 26 deletions(-)
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/DropletChecker.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/DropletLoader.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/GenericTypeSearchVisitor.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/UnderlineErrorListener.java
 delete mode 100644 src/main/java/ru/ftc/upc/testing/dropper/model/Droplet.java
 create mode 100644 src/main/java/ru/ftc/upc/testing/dropper/model/DropletV2.java
 create mode 100644 src/test/java/ru/ftc/upc/testing/dropper/DropletLoaderTest.java
 create mode 100644 src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass.java
 create mode 100644 src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass2.java

diff --git a/build.gradle b/build.gradle
index 68e5ecd..3cacdbf 100644
--- a/build.gradle
+++ b/build.gradle
@@ -26,7 +26,8 @@ jar {
     manifest {
         attributes("Implementation-Title": "Dropper",
                 "Implementation-Version": version,
-                "Premain-Class": "ru.ftc.upc.testing.dropper.DropperAgent")
+                "Premain-Class": "ru.ftc.upc.testing.dropper.DropperAgent",
+                "Main-Class": "ru.ftc.upc.testing.dropper.DropletChecker")
     }
 
     from {
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/DropletChecker.java b/src/main/java/ru/ftc/upc/testing/dropper/DropletChecker.java
new file mode 100644
index 0000000..6bebc31
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/DropletChecker.java
@@ -0,0 +1,28 @@
+package ru.ftc.upc.testing.dropper;
+
+import ru.ftc.upc.testing.dropper.model.TargetsMap;
+
+/**
+ * @author Toparvion
+ */
+public class DropletChecker {
+
+  public static void main(String[] args) {
+    if (args.length != 1) {
+      System.out.printf(USAGE_HELP);
+      return;
+    }
+
+    TargetsMap targetsMap = DropletLoader.loadDroplets(args[0]);
+    System.out.printf("Loaded targets map:\n%s", targetsMap.toString());
+
+    System.out.println("\nDroplet(s) format is OK.");
+  }
+
+  private static final String USAGE_HELP = "Usage: java -jar dropper.jar <droplet-list>\n" +
+          "   Argument <droplet-list> is a semicolon-separated list of droplet files to check.\n" +
+          "   The list is exactly the" +
+          " same as one that should be given to dropper in usual (java agent) mode after '=' sign,\n" +
+          "   i.e. -javaagent:dropper.jar=BusinessClassDroplet.java;SystemClassDroplet.java.\nExample:\n" +
+          "   java -jar dropper.jar BusinessClassDroplet.java;SystemClassDroplet.java";
+}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/DropletLoader.java b/src/main/java/ru/ftc/upc/testing/dropper/DropletLoader.java
new file mode 100644
index 0000000..303b322
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/DropletLoader.java
@@ -0,0 +1,63 @@
+package ru.ftc.upc.testing.dropper;
+
+import org.antlr.v4.runtime.ANTLRFileStream;
+import org.antlr.v4.runtime.BufferedTokenStream;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.RecognitionException;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+import ru.ftc.upc.testing.dropper.lang.DropletAssembler;
+import ru.ftc.upc.testing.dropper.lang.DropletFormatException;
+import ru.ftc.upc.testing.dropper.lang.UnderlineErrorListener;
+import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaLexer;
+import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
+import ru.ftc.upc.testing.dropper.model.TargetsMap;
+
+import java.io.IOException;
+
+/**
+ * @author Toparvion
+ */
+abstract class DropletLoader {
+
+  static TargetsMap loadDroplets(String args) {
+    String[] argTokens = args.split("[;,]");
+    // at the moment we support only one argument file format - droplet format, thus file extension doesn't matter
+    TargetsMap targetsMap = new TargetsMap();
+    for (String argToken : argTokens) {
+      try {
+        targetsMap.putAll(loadSingleDroplet(argToken));
+
+      } catch (IOException e) {
+        System.err.printf("Failed to load droplet '%s'. Skipped.", argToken);
+        e.printStackTrace();
+
+      } catch (DropletFormatException e) {
+        System.err.printf("Error during parsing droplet '%s'. Droplet is skipped.\n%s\n", argToken, e.getMessage());
+
+      }
+    }
+    return targetsMap;
+  }
+
+  private static TargetsMap loadSingleDroplet(String dropletPath) throws IOException, RecognitionException {
+    DropletAssembler assembler = parseAndGetAssembler(dropletPath);
+    return assembler.getTargetsMap();
+  }
+
+  private static DropletAssembler parseAndGetAssembler(String dropletPath) throws IOException {
+    ANTLRFileStream fileStream = new ANTLRFileStream(dropletPath);
+    DroppingJavaLexer lexer = new DroppingJavaLexer(fileStream);
+    BufferedTokenStream tokenStream = new CommonTokenStream(lexer);
+    DroppingJavaParser parser = new DroppingJavaParser(tokenStream);
+    parser.removeErrorListeners();
+    parser.addErrorListener(new UnderlineErrorListener());
+    ParseTree tree = parser.compilationUnit();
+
+    DropletAssembler assembler = new DropletAssembler(tokenStream);
+    ParseTreeWalker walker = new ParseTreeWalker();
+    walker.walk(assembler, tree);
+    return assembler;
+  }
+
+}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
index a2d98f4..da9f041 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
@@ -21,7 +21,7 @@
  * listener.
  * @author Toparvion
  */
-class DropletAssembler extends DroppingJavaBaseListener {
+public class DropletAssembler extends DroppingJavaBaseListener {
 
   /**
    * Mapping between simple type names (e.g. "Droplet") and their FQ prefixes (e.g. "ru.ftc.upc.testing.dropper").
@@ -48,7 +48,7 @@ class DropletAssembler extends DroppingJavaBaseListener {
    */
   private final BufferedTokenStream tokenStream;
 
-  DropletAssembler(BufferedTokenStream tokenStream) {
+  public DropletAssembler(BufferedTokenStream tokenStream) {
     this.tokenStream = tokenStream;
   }
 
@@ -80,8 +80,8 @@ public void enterSingleTypeImportDeclaration(DroppingJavaParser.SingleTypeImport
   public void enterTypeImportOnDemandDeclaration(DroppingJavaParser.TypeImportOnDemandDeclarationContext ctx) {
     Token offendingToken = ctx.getToken(DroppingJavaParser.IMPORT, 0).getSymbol();
     String offendingImportString = String.format("import %s.*;", ctx.packageOrTypeName().getText());
-    throw new DropletFormatException(String.format("Line %d:%d. Type imports on demand are not supported: '%s'. " +
-                    "Please replace it with a set of single type imports.",
+    throw new DropletFormatException(String.format("Line %d:%d - Type imports on demand are not supported. " +
+                    "Please replace it with a set of single type imports:\n%s\n",
             offendingToken.getLine(), offendingToken.getCharPositionInLine(), offendingImportString));
   }
 
@@ -117,6 +117,8 @@ public void exitNormalInterfaceDeclaration(DroppingJavaParser.NormalInterfaceDec
    */
   @Override
   public void enterConstructorDeclarator(DroppingJavaParser.ConstructorDeclaratorContext ctx) {
+    // at this moment the underlying system doesn't support parametrized types in methods so we have to inform the user
+    checkForParametrizedTypesPresence(ctx);             // throws DropletFormatException if type params found
     // as we consider constructor as methods, let's firstly initialize it
     TargetMethod method = new TargetMethod(ctx.simpleTypeName().getText());
 
@@ -130,6 +132,8 @@ public void enterConstructorDeclarator(DroppingJavaParser.ConstructorDeclaratorC
 
   @Override
   public void enterMethodHeader(DroppingJavaParser.MethodHeaderContext ctx) {
+    // at this moment the underlying system doesn't support parametrized types in methods so we have to inform the user
+    checkForParametrizedTypesPresence(ctx);             // throws DropletFormatException if type params found
     // first of all let's initialize this method itself
     DroppingJavaParser.MethodDeclaratorContext declarator = ctx.methodDeclarator();
     TargetMethod method = new TargetMethod(declarator.Identifier().getText());
@@ -294,7 +298,7 @@ private String composeCurrentKey() {
       } else {
         first = false;
       }
-      className = className.replaceFirst("(?i)_?Droplet$", "");     // todo allow customizing through settings
+      className = className.replaceFirst("(?i)_?Droplet$", "");
       sb.append(className);
     }
 
@@ -368,10 +372,27 @@ private String obfuscateParameterReferences(String bodyText, List<Argument> form
     }
     return processedText;
   }
+
+  /**
+   * Checks for presence of parametrized types in given rule context and throws DropletFormatException if finds.
+   * Due to error in the original grammar this method doesn't detects generic types of formal parameters though the
+   * visitor has special handling for it.
+   * @param ctx parser rule context
+   */
+  private void checkForParametrizedTypesPresence(ParserRuleContext ctx) {
+    DroppingJavaVisitor<ParserRuleContext> visitor = new GenericTypeSearchVisitor();
+    ParserRuleContext token = visitor.visit(ctx);
+    if (token != null) {
+      String message = String.format("Line %d:%d - %s: %s", token.getStart().getLine(),
+              token.getStart().getCharPositionInLine(),
+              "Methods with parametrized types are not supported", new BodyComposingVisitor().visit(token));
+      throw new DropletFormatException(message);
+    }
+  }
   //endregion
 
   //region Getters
-  TargetsMap getTargetsMap() {
+  public TargetsMap getTargetsMap() {
     return targetsMap;
   }
 
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/GenericTypeSearchVisitor.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/GenericTypeSearchVisitor.java
new file mode 100644
index 0000000..5b923ca
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/GenericTypeSearchVisitor.java
@@ -0,0 +1,27 @@
+package ru.ftc.upc.testing.dropper.lang;
+
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.tree.RuleNode;
+import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaBaseVisitor;
+import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
+
+/**
+ * @author Toparvion
+ */
+class GenericTypeSearchVisitor extends DroppingJavaBaseVisitor<ParserRuleContext> {
+
+  @Override
+  protected boolean shouldVisitNextChild(RuleNode node, ParserRuleContext currentResult) {
+    return (currentResult == null);
+  }
+
+  @Override
+  public ParserRuleContext visitUnannTypeVariable(DroppingJavaParser.UnannTypeVariableContext ctx) {
+    return ctx;
+  }
+
+  @Override
+  public ParserRuleContext visitTypeParameters(DroppingJavaParser.TypeParametersContext ctx) {
+    return ctx;
+  }
+}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/UnderlineErrorListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/UnderlineErrorListener.java
new file mode 100644
index 0000000..2265972
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/UnderlineErrorListener.java
@@ -0,0 +1,46 @@
+package ru.ftc.upc.testing.dropper.lang;
+
+import org.antlr.v4.runtime.*;
+
+public class UnderlineErrorListener extends BaseErrorListener {
+
+  @Override
+  public void syntaxError(Recognizer<?, ?> recognizer,
+                          Object offendingSymbol,
+                          int line,
+                          int charPositionInLine,
+                          String msg,
+                          RecognitionException e) {
+    String underline = underlineError(recognizer, (Token) offendingSymbol, line, charPositionInLine);
+    String message = String.format("Line %d:%d - %s%s", line, charPositionInLine, msg, underline);
+    throw new DropletFormatException(message);
+  }
+
+  private String underlineError(Recognizer recognizer,
+                              Token offendingToken, int line,
+                              int charPositionInLine) {
+    try {
+      CommonTokenStream tokens = (CommonTokenStream) recognizer.getInputStream();
+      String input = tokens.getTokenSource().getInputStream().toString();
+      String[] lines = input.split("\n");
+      String errorLine = lines[line - 1];
+      StringBuilder sb = new StringBuilder(":\n")
+              .append(errorLine)
+              .append("\n");
+      for (int i = 0; i < charPositionInLine; i++)
+        sb.append(" ");
+      int start = offendingToken.getStartIndex();
+      int stop = offendingToken.getStopIndex();
+      if (start >= 0 && stop >= 0) {
+        for (int i = start; i <= stop; i++)
+          sb.append("^");
+      }
+      return sb.append("\n").toString();
+
+    } catch (Exception e) {
+      // Due to method bodies collapsing exact error symbol locating is not always possible, for example when the
+      // offending symbol goes after collapsed body. In such cases we don't provide underlining (leaving it empty).
+      return "\n";
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/Droplet.java b/src/main/java/ru/ftc/upc/testing/dropper/model/Droplet.java
deleted file mode 100644
index 52a723e..0000000
--- a/src/main/java/ru/ftc/upc/testing/dropper/model/Droplet.java
+++ /dev/null
@@ -1,8 +0,0 @@
-package ru.ftc.upc.testing.dropper.model;
-
-/**
- * @author Toparvion
- */
-public class Droplet {
-
-}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/DropletV2.java b/src/main/java/ru/ftc/upc/testing/dropper/model/DropletV2.java
new file mode 100644
index 0000000..d5dda0b
--- /dev/null
+++ b/src/main/java/ru/ftc/upc/testing/dropper/model/DropletV2.java
@@ -0,0 +1,23 @@
+package ru.ftc.upc.testing.dropper.model;
+
+/**
+ * @author Toparvion
+ */
+public class DropletV2 {
+
+  private final String path;
+  private final TargetsMap targetsMap;
+
+  public DropletV2(String path, TargetsMap targetsMap) {
+    this.path = path;
+    this.targetsMap = targetsMap;
+  }
+
+  public String getPath() {
+    return path;
+  }
+
+  public TargetsMap getTargetsMap() {
+    return targetsMap;
+  }
+}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java
index e9516fd..66e5ff1 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java
@@ -20,6 +20,26 @@ public void put(String key, TargetMethod method) {
     }
   }
 
+  /**
+   * Method is overridden in order to provide non-destructive and duplicates-free merging of two targets maps.
+   * @param m targets map to merge with this one
+   */
+  @Override
+  public void putAll(Map<? extends String, ? extends Deque<TargetMethod>> m) {
+    for (Map.Entry<? extends String, ? extends Deque<TargetMethod>> entry : m.entrySet()) {
+      String classFqName = entry.getKey();
+      Deque<TargetMethod> oldMethods = this.get(classFqName);
+      if (oldMethods != null) {
+        for (TargetMethod newMethod : entry.getValue()) {
+          checkForDuplicate(oldMethods, newMethod, classFqName); // throws IllegalArgumentException if a duplicate found
+          oldMethods.addLast(newMethod);
+        }
+      } else {
+        this.put(classFqName, entry.getValue());
+      }
+    }
+  }
+
   private void checkForDuplicate(Deque<TargetMethod> methods, TargetMethod newMethod, String classFqName)
           throws IllegalArgumentException {
     for (TargetMethod oldMethod : methods) {
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/DropletLoaderTest.java b/src/test/java/ru/ftc/upc/testing/dropper/DropletLoaderTest.java
new file mode 100644
index 0000000..b625d58
--- /dev/null
+++ b/src/test/java/ru/ftc/upc/testing/dropper/DropletLoaderTest.java
@@ -0,0 +1,18 @@
+package ru.ftc.upc.testing.dropper;
+
+import org.junit.Test;
+import ru.ftc.upc.testing.dropper.model.TargetsMap;
+
+/**
+ * @author Toparvion
+ */
+public class DropletLoaderTest {
+
+  @Test
+  public void loadDroplets() throws Exception {
+    String args = "src/test/resources/DPClientImpl.java;src/test/resources/DPClientImpl2.java";
+    TargetsMap targetsMap = DropletLoader.loadDroplets(args);
+    System.out.printf("Targets map:\n%s", targetsMap.toString());
+  }
+
+}
\ No newline at end of file
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
index f2915a2..7585755 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
@@ -82,9 +82,6 @@ public void methodHeadersAreRecognizedFully() throws Exception {
             "\tTargetMethod{name='method8', cutpoint=INSTEAD, resultType=java.util.Set, formalParams=(java.util.EventObject eo), text=\n" +
             "\t\treturn java.util.Collections . emptySet ( ) ;\n" +
             "\t}\n" +
-            "\tTargetMethod{name='method9', cutpoint=INSTEAD, resultType=T, formalParams=(T source, boolean flag), text=\n" +
-            "\t\treturn ( T ) new java.io.BufferedInputStream ( $1 ) ;\n" +
-            "\t}\n" +
             "}\n" +
             "ru.ftc.upc.testing.dropper.lang.samples.VariousMethodHeaders$InnerClass -> {\n" +
             "\tTargetMethod{name='InnerClass', cutpoint=INSTEAD, resultType=null, formalParams=(java.util.Deque arg), text=(empty)}\n" +
@@ -320,6 +317,25 @@ public void methodDuplicatesAreDetectedCorrectly() throws Exception {
 
   }
 
+  @Test(expected = DropletFormatException.class)
+  public void parametrizedMethodsAreNotSupported() throws Exception {
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass.java";
+    TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
+    String actual = targetsMap.toString();
+    System.out.println(actual);
+  }
+
+  /**
+   * This test must fail but due to bug in grammar it doesn't happen. The test left for fixing the bug in future.
+   */
+  @Test(/*expected = DropletFormatException.class*/)
+  public void parametrizedParametersInMethodsAreNotSupported() throws Exception {
+    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass2.java";
+    TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
+    String actual = targetsMap.toString();
+    System.out.println(actual);
+  }
+
   private DropletAssembler loadDroplet(String dropletPath) throws IOException {
     ANTLRFileStream fileStream = new ANTLRFileStream(dropletPath);
     DroppingJavaLexer lexer = new DroppingJavaLexer(fileStream);
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass.java
new file mode 100644
index 0000000..b9e3fbc
--- /dev/null
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass.java
@@ -0,0 +1,26 @@
+package ru.ftc.upc.testing.dropper.lang.samples;
+
+import java.io.InputStream;
+import java.util.AbstractSet;
+import java.util.Iterator;
+
+/**
+ * @author Toparvion
+ */
+@SuppressWarnings("unused")
+public class GenericClass<T> extends AbstractSet<T> {
+
+  @Override
+  public Iterator<T> iterator() {
+    return null;
+  }
+
+  @Override
+  public int size() {
+    return 0;
+  }
+
+  public <R extends InputStream> void method2(R arg) {
+    System.out.println(arg.toString());
+  }
+}
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass2.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass2.java
new file mode 100644
index 0000000..4f88e36
--- /dev/null
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass2.java
@@ -0,0 +1,25 @@
+package ru.ftc.upc.testing.dropper.lang.samples;
+
+import java.util.AbstractSet;
+import java.util.Iterator;
+
+/**
+ * @author Toparvion
+ */
+@SuppressWarnings("unused")
+public class GenericClass2<T> extends AbstractSet<T> {
+
+  @Override
+  public Iterator<T> iterator() {
+    return null;
+  }
+
+  @Override
+  public int size() {
+    return 0;
+  }
+
+  public void method2(T arg) {
+    System.out.println(arg.toString());
+  }
+}
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java
index 6ccac79..4291bf5 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java
@@ -15,9 +15,6 @@
 import java.util.Stack;
 import java.util.UUID;
 
-/**
- * @author Toparvion
- */
 @SuppressWarnings("unused")
 public class VariousMethodHeaders {
 
@@ -51,9 +48,4 @@ Set<Currency> method8(EventObject eo) {
     return Collections.emptySet();
   }
 
-  @SuppressWarnings("unchecked")
-  private <T extends InputStream> T method9(T source, boolean flag)
-          throws FileNotFoundException {
-    return (T) new BufferedInputStream(source);
-  }
 }

From 5ceed55d125305842afe4aea31af7cad1f34f47b Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Sat, 2 Jul 2016 23:34:41 +0600
Subject: [PATCH 16/22] Javassistification. Part 1.

---
 build.gradle                                  |   2 +-
 .../ru/ftc/upc/testing/dropper/Cutpoint.java  |  30 +++-
 .../upc/testing/dropper/DropletLoader.java    |   9 +-
 .../ftc/upc/testing/dropper/DropperAgent.java |  21 +--
 .../testing/dropper/PatchingTransformer.java  | 123 ++++++++++-----
 .../dropper/lang/CutpointAssembler.java       |   1 -
 .../dropper/lang/DropletAssembler.java        | 147 +++++++++++-------
 .../dropper/lang/UnderlineErrorListener.java  |   2 +-
 .../testing/dropper/model/TargetMethod.java   |  42 +++--
 .../dropper/modify/AfterBodyModifier.java     |   7 +-
 .../dropper/modify/BeforeBodyModifier.java    |   7 +-
 .../dropper/modify/InsteadBodyModifier.java   |   7 +-
 .../dropper/modify/MethodModifier.java        |   5 +-
 .../dropper/lang/CutpointAssemblerTest.java   |  18 +++
 .../dropper/lang/DropletAssemblerTest.java    |  91 ++++++-----
 src/test/resources/Cutpoint_6.javadoc         |   8 +
 src/test/resources/Cutpoint_7.javadoc         |   1 +
 src/test/resources/DrawPaneDroplet.java       |  39 +++++
 src/test/resources/FaultyImports.java         |  13 --
 src/test/resources/Imports.java               |   9 ++
 20 files changed, 387 insertions(+), 195 deletions(-)
 create mode 100644 src/test/resources/Cutpoint_6.javadoc
 create mode 100644 src/test/resources/Cutpoint_7.javadoc
 create mode 100644 src/test/resources/DrawPaneDroplet.java
 delete mode 100644 src/test/resources/FaultyImports.java

diff --git a/build.gradle b/build.gradle
index 3cacdbf..e98edb4 100644
--- a/build.gradle
+++ b/build.gradle
@@ -15,7 +15,7 @@ configurations {
 }
 
 dependencies {
-    provided 'org.javassist:javassist:3.20.0-GA'
+    compile 'org.javassist:javassist:3.20.0-GA'
     compile 'org.slf4j:slf4j-api:1.7.7'
     // http://mvnrepository.com/artifact/org.antlr/antlr4-runtime
     compile group: 'org.antlr', name: 'antlr4-runtime', version: '4.5.3'
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java b/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java
index 0b8043b..6a95df6 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java
@@ -8,17 +8,37 @@
 /**
  * Created by Toparvion on 29.04.2016 11:59
  */
-@SuppressWarnings("unused")       // all the elements of the Enum is actually used through Enum#valueOf()
 public enum Cutpoint {
   BEFORE(BeforeBodyModifier.class),
   INSTEAD(InsteadBodyModifier.class),
   AFTER(AfterBodyModifier.class),
-  CATCH(MethodModifier.class);           // TODO implement dedicated patcher
+  CATCH(MethodModifier.class),                // TODO implement dedicated modifier
+  /**
+   * This synthetic cutpoint is introduced to denote a method that must not be instrumented. This however doesn't
+   * mean that the method must not be included into targets map. It is still included there to avoid breaking the
+   * order of tree walking.
+   */
+  IGNORE(MethodModifier.class /* <- the modifier is just a stub as this cutpoint is never actually applied */);
 
-  final Class<? extends MethodModifier> patcherClass;
+  final Class<? extends MethodModifier> modifierClass;
 
-  Cutpoint(Class<? extends MethodModifier> patcherClass) {
-    this.patcherClass = patcherClass;
+  Cutpoint(Class<? extends MethodModifier> modifierClass) {
+    this.modifierClass = modifierClass;
+  }
+
+  /**
+   * Finds the enum element matching given name or fails back to {@code INSTEAD} if none can be found.
+   * @param name the name to find matching cutpoint for
+   * @return cutpoint with the same name or {@code INSTEAD} if not found
+   */
+  public static Cutpoint getByNameSafe(String name) {
+    if (name == null) return INSTEAD;
+    for (Cutpoint cutpoint : values()) {
+      if (cutpoint.toString().equalsIgnoreCase(name)) {
+        return cutpoint;
+      }
+    }
+    return INSTEAD;
   }
 
 }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/DropletLoader.java b/src/main/java/ru/ftc/upc/testing/dropper/DropletLoader.java
index 303b322..34d8a83 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/DropletLoader.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/DropletLoader.java
@@ -23,10 +23,10 @@ abstract class DropletLoader {
   static TargetsMap loadDroplets(String args) {
     String[] argTokens = args.split("[;,]");
     // at the moment we support only one argument file format - droplet format, thus file extension doesn't matter
-    TargetsMap targetsMap = new TargetsMap();
+    TargetsMap overallMap = new TargetsMap();
     for (String argToken : argTokens) {
       try {
-        targetsMap.putAll(loadSingleDroplet(argToken));
+        overallMap.putAll(loadSingleDroplet(argToken));
 
       } catch (IOException e) {
         System.err.printf("Failed to load droplet '%s'. Skipped.", argToken);
@@ -35,9 +35,12 @@ static TargetsMap loadDroplets(String args) {
       } catch (DropletFormatException e) {
         System.err.printf("Error during parsing droplet '%s'. Droplet is skipped.\n%s\n", argToken, e.getMessage());
 
+      } catch (Exception e) {
+        System.err.printf("Failed to load droplet '%s'. Skipped.", argToken);
+        e.printStackTrace();
       }
     }
-    return targetsMap;
+    return overallMap;
   }
 
   private static TargetsMap loadSingleDroplet(String dropletPath) throws IOException, RecognitionException {
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java b/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java
index e4ce050..2138bad 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java
@@ -2,12 +2,14 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import ru.ftc.upc.testing.dropper.model.TargetsMap;
 
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
 import java.io.IOException;
 import java.lang.instrument.Instrumentation;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.regex.Matcher;
@@ -28,23 +30,22 @@ public static void premain(String agentArgs, Instrumentation inst) {
     System.out.println(DROPPER_LOGO);
 
     Package pack = DropperAgent.class.getPackage();
-    log.info("{} started (version: {}).", pack.getImplementationTitle(), pack.getImplementationVersion());
+    System.out.printf("%s started (version: %s).\n", pack.getImplementationTitle(), pack.getImplementationVersion());
 
-    Set<Droplet> droplets = getDroplets(agentArgs);
-    for (Droplet droplet : droplets) {
-      log.info("Loaded droplet: {}", droplet);
-    }
+    long startTime = System.currentTimeMillis();
+    TargetsMap targetsMap = DropletLoader.loadDroplets(agentArgs);
+    System.out.printf("Loaded targets map:\n%s\n", targetsMap.toString());
+    System.out.printf("Droplets loading took: %s ms\n", (System.currentTimeMillis()-startTime));
 
-    if (droplets.isEmpty()) {
-      log.warn("No droplets to inject left after arguments processing.");
+    if (targetsMap.isEmpty()) {
+      System.out.printf("No droplets to apply left after arguments processing. No byte code will be modified.\n");
     } else {
-      log.info("Total {} droplets loaded.", droplets.size());
-      inst.addTransformer(new PatchingTransformer(droplets));
+      inst.addTransformer(new PatchingTransformer(targetsMap));
     }
   }
 
   private static Set<Droplet> getDroplets(String args) {
-    if (args == null || "".equals(args)) throw new IllegalArgumentException("No arguments supplied.");
+    if (args == null || "".equals(args)) return Collections.emptySet();
 
     Set<Droplet> droplets = new HashSet<Droplet>();
     String[] argTokens = args.split(";");
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java b/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java
index 724bcfc..4a5a83d 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java
@@ -1,38 +1,31 @@
 package ru.ftc.upc.testing.dropper;
 
-import javassist.ByteArrayClassPath;
-import javassist.ClassPool;
-import javassist.CtClass;
-import javassist.CtMethod;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import javassist.*;
+import ru.ftc.upc.testing.dropper.model.Argument;
+import ru.ftc.upc.testing.dropper.model.TargetMethod;
+import ru.ftc.upc.testing.dropper.model.TargetsMap;
 import ru.ftc.upc.testing.dropper.modify.MethodModifier;
 
 import java.lang.instrument.ClassFileTransformer;
 import java.lang.instrument.IllegalClassFormatException;
 import java.security.ProtectionDomain;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 
 import static java.lang.String.format;
+import static ru.ftc.upc.testing.dropper.Cutpoint.IGNORE;
 
 /**
  * Created by Toparvion on 29.04.2016 12:50
  */
 class PatchingTransformer implements ClassFileTransformer {
-  private static final Logger log = LoggerFactory.getLogger(PatchingTransformer.class);
+  private ClassPool pool;
+  private final TargetsMap targetsMap;
+  private final Set<ClassLoader> knownLoaders = new HashSet<ClassLoader>();
+  private final Set<String> knownPackages = new HashSet<String>();
 
-  private final Map<String, Droplet> dropletMap = new HashMap<String, Droplet>();
-  private final ClassPool pool;
-
-  PatchingTransformer(Set<Droplet> droplets) {
-    pool = ClassPool.getDefault();
-
-    for (Droplet droplet : droplets) {
-      String jvmClazzFqName = droplet.getClazz().replaceAll("\\.", "/");
-      dropletMap.put(jvmClazzFqName, droplet);
-    }
+  PatchingTransformer(TargetsMap targetsMap) {
+    this.targetsMap = targetsMap;
+    this.pool = ClassPool.getDefault();
   }
 
   @Override
@@ -41,32 +34,86 @@ public byte[] transform(ClassLoader loader,
                           Class<?> classBeingRedefined,
                           ProtectionDomain protectionDomain,
                           byte[] classFileBuffer) throws IllegalClassFormatException {
-    if (!dropletMap.containsKey(className)) {
+    // first of all let's check if we're interested in this class
+    if (!targetsMap.containsKey(className)) {
       return null;
     }
+    // this class is of interest, so let's try to modify it
     try {
-      return applyDroplet(dropletMap.get(className), classFileBuffer);
+      if (knownLoaders.add(loader)) {           // TODO avoid explicit loaders comparison
+        ClassPool childPool = new ClassPool(pool);
+        childPool.childFirstLookup = true;
+        pool = childPool;
+      }
+
+      // locate the class in the pool, taking the classFileBuffer as a source
+      Deque<TargetMethod> targetMethods = targetsMap.get(className);
+      String dottedClassName = className.replace("/", ".");
+      pool.insertClassPath(new ByteArrayClassPath(dottedClassName, classFileBuffer));
+      CtClass ctClass = pool.get(dottedClassName);
+
+      // iterate over desired methods trying to modify each one
+      for (TargetMethod targetMethod : targetMethods) {
+        try {
+          if (IGNORE.equals(targetMethod.getCutpoint())) {
+            System.out.printf("Method '%s#%s' is skipped due to IGNORE cutpoint.\n", dottedClassName, targetMethod.getName());
+            continue;
+          }
+          // in order to precisely select method to modify we need CtClass representation of all its parameters
+          CtClass[] argsArray = javassistifyArguments(targetMethod.getFormalParams(), targetMethod.getImportsOnDemand());
+
+          // pick javassist representation of target method
+          CtBehavior ctMethod = (targetMethod.getResultType() != null)        // constructors do not have result type
+                  ? ctClass.getDeclaredMethod(targetMethod.getName(), argsArray)
+                  : ctClass.getDeclaredConstructor(argsArray);
+
+          // prepare javassist compiler to resolve not fully qualified types
+          for (String importEntry : targetMethod.getImportsOnDemand()) {
+            if (knownPackages.add(importEntry)) {
+              pool.importPackage(importEntry);
+            }
+          }
+
+          // apply modification via corresponding cutpoint
+          Cutpoint cutpoint = targetMethod.getCutpoint();
+          MethodModifier modifier = cutpoint.modifierClass.newInstance();
+          modifier.apply(ctMethod, targetMethod.getText());
+          System.out.printf("Method '%s' has been modified at %s cutpoint.\n", ctMethod.getLongName(), cutpoint);
+
+        } catch (Exception e) {
+          System.out.printf("Failed to modify target method '%s#%s'. Skipped.\n", dottedClassName, targetMethod.getName());
+          e.printStackTrace();
+        }
+      }
+      return ctClass.toBytecode();
 
     } catch (Exception e) {
-      log.error(format("Failed to modify class '%s'. Class skipped.", className), e);
+      System.out.println(format("Failed to modify class '%s'. Skipped.", className));
+      e.printStackTrace();
       return null;
     }
   }
 
-  private byte[] applyDroplet(Droplet droplet, byte[] classFileBuffer) throws Exception {
-    String className = droplet.getClazz();
-    pool.insertClassPath(new ByteArrayClassPath(className, classFileBuffer));
-    CtClass ctClass = pool.get(className);
-    if (ctClass.isFrozen())
-      throw new IllegalStateException(format("Class '%s' is frozen.", ctClass.getName()));
-
-    CtMethod ctMethod = ctClass.getDeclaredMethod(droplet.getMethod());
-
-    Cutpoint cutpoint = droplet.getCutpoint();
-    MethodModifier patcher = cutpoint.patcherClass.newInstance();
-
-    patcher.apply(ctMethod, droplet);
-    log.info("Class {} has been modified with {}.", ctClass.getName(), patcher.getClass().getSimpleName());
-    return ctClass.toBytecode();
+  private CtClass[] javassistifyArguments(List<Argument> args, Set<String> importsOnDemand) throws NotFoundException {
+    List<CtClass> argCtClasses = new ArrayList<CtClass>(args.size());
+    for (Argument arg : args) {
+      String argumentTypeName = arg.getType();
+      CtClass argumentCtClass = pool.getOrNull(argumentTypeName);
+      // if this arg has not been found in the pool, let's try to prepend its name with various imports on demand
+      if (argumentCtClass == null) {
+        for (String importEntry : importsOnDemand) {
+          argumentCtClass = pool.getOrNull(importEntry + "." + arg.getType());
+          if (argumentCtClass != null) {
+            break;
+          }
+        }
+        if (argumentCtClass == null) {
+          throw new NotFoundException(format("Couldn't resolve argument '%s %s'.", arg.getType(), arg.getName()));
+        }
+      }
+      argCtClasses.add(argumentCtClass);
+    }
+    return argCtClasses.toArray(new CtClass[args.size()]);
   }
+
 }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/CutpointAssembler.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/CutpointAssembler.java
index 0bac268..7adb5a0 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/CutpointAssembler.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/CutpointAssembler.java
@@ -9,7 +9,6 @@
  * @author Toparvion
  */
 class CutpointAssembler extends JavadocParserBaseListener {
-
   private static final String CUTPOINT_TAG_NAME = "cutpoint";
 
   private String tagValue;
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
index da9f041..3676aca 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
@@ -15,6 +15,7 @@
 import java.util.regex.Pattern;
 
 import static java.util.regex.Matcher.quoteReplacement;
+import static ru.ftc.upc.testing.dropper.Cutpoint.IGNORE;
 
 /**
  * The main class responsible for extracting valuable data from droplet files. Built upon ANTLR parse tree event
@@ -23,22 +24,31 @@
  */
 public class DropletAssembler extends DroppingJavaBaseListener {
 
-  /**
-   * Mapping between simple type names (e.g. "Droplet") and their FQ prefixes (e.g. "ru.ftc.upc.testing.dropper").
-   * The mapping is built upon the import statements at the header of compilation unit and does not include any type
-   * imports on demand.
-   */
-  private final Map<String, String> importsMap = new LinkedHashMap<String, String>(10);
   /**
    * Mapping between all target classes and lists of their methods. These methods are targets for byte
    * code instrumenting.
    */
   private final TargetsMap targetsMap = new TargetsMap();
 
+  /**
+   * Mapping between simple type names (e.g. {@code Droplet}) and their FQ prefixes (e.g.
+   * {@code ru.ftc.upc.testing.dropper}).
+   * The mapping is built upon the import statements at the header of compilation unit. <br/>
+   * It also includes single static imports (e.g. {@code import static java.lang.Integer.MAX_VALUE}) and does not
+   * include any type imports on demand (neither {@code java.util.*} nor {@code import static java.lang.Double.*}).
+   */
+  /*private - for unit tests*/ final Map<String, String> singleImportsMap = new LinkedHashMap<String, String>(10);
+
   /**
    * Package prefix for the target type(s), e.g. "tech.toparvion.dropper.lang.droplets."
    */
   private String packageDeclaration = "";
+  /**
+   * A set of non-static imports on demand. Includes package names only (without {@code .* chars}).<br/>
+   * The set is used later at the instrumentation phase for resolving FQ-names of methods' formal parameters as well
+   * as for importing the packages into Javassist compiler.
+   */
+  private final Set<String> importsOnDemand = new LinkedHashSet<String>();
   /**
    * Internal stack aimed to support depth tracking during parse tree traversing.
    */
@@ -60,6 +70,8 @@ public void enterPackageDeclaration(DroppingJavaParser.PackageDeclarationContext
       sb.append(idNode.getText()).append(".");
     }
     this.packageDeclaration = sb.toString();
+    // the very first import on demand is the containing package itself (used later to 'javassistify' formal parameters)
+    this.importsOnDemand.add(sb.substring(0, sb.length()-1));
   }
 
   @Override
@@ -69,20 +81,33 @@ public void enterSingleTypeImportDeclaration(DroppingJavaParser.SingleTypeImport
       // in this case there is no profit in mapping a type to its import prefix so that we just ignore it
       return;
     }
-    importsMap.put(typeName.Identifier().getText(), typeName.packageOrTypeName().getText());
+    singleImportsMap.put(typeName.Identifier().getText(), typeName.packageOrTypeName().getText());
+  }
+
+  @Override
+  public void enterSingleStaticImportDeclaration(DroppingJavaParser.SingleStaticImportDeclarationContext ctx) {
+    DroppingJavaParser.TypeNameContext typeName = ctx.typeName();
+    singleImportsMap.put(ctx.Identifier().getText(), typeName.getText());
   }
 
-  /**
-   * Type imports on demand are not supported in this version because they introduce quite complicated ambiguity. In
-   * order not to mute their existence we prefer to explicitly inform the user about them with the help of exception.
-   */
   @Override
   public void enterTypeImportOnDemandDeclaration(DroppingJavaParser.TypeImportOnDemandDeclarationContext ctx) {
+    importsOnDemand.add(ctx.packageOrTypeName().getText());
+  }
+
+  @Override
+  public void enterStaticImportOnDemandDeclaration(DroppingJavaParser.StaticImportOnDemandDeclarationContext ctx) {
+    /**
+     * Static type imports on demand are not supported in this version because they introduce quite complicated
+     * ambiguity. In order not to mute their existence, we prefer to explicitly inform the user about them with the
+     * help of warning.
+     */
     Token offendingToken = ctx.getToken(DroppingJavaParser.IMPORT, 0).getSymbol();
-    String offendingImportString = String.format("import %s.*;", ctx.packageOrTypeName().getText());
-    throw new DropletFormatException(String.format("Line %d:%d - Type imports on demand are not supported. " +
-                    "Please replace it with a set of single type imports:\n%s\n",
-            offendingToken.getLine(), offendingToken.getCharPositionInLine(), offendingImportString));
+    String offendingImportString = String.format("import static %s.*;", ctx.typeName().getText());
+    System.out.printf("WARNING: Static imports on demand are not " +
+            "supported. If they are used in not ignored methods please replace " +
+            "them with a set of single static imports.\nLine %d:%d - %s\n",
+            offendingToken.getLine(), offendingToken.getCharPositionInLine(), offendingImportString);
   }
 
   @Override
@@ -112,31 +137,40 @@ public void exitNormalInterfaceDeclaration(DroppingJavaParser.NormalInterfaceDec
     classNameStack.pop();
   }
 
-  /**
-   * We treat constructors much like any other methods but still take in account some grammar differences.
-   */
   @Override
   public void enterConstructorDeclarator(DroppingJavaParser.ConstructorDeclaratorContext ctx) {
-    // at this moment the underlying system doesn't support parametrized types in methods so we have to inform the user
-    checkForParametrizedTypesPresence(ctx);             // throws DropletFormatException if type params found
-    // as we consider constructor as methods, let's firstly initialize it
-    TargetMethod method = new TargetMethod(ctx.simpleTypeName().getText());
+    // constructors are treated much like any other methods but still some grammar differences are taken in count
+    String constructorName = omitDropletSuffix(ctx.simpleTypeName().getText());
+    // let's start from extracting the cutpoint from preceding javadoc comment, if any
+    Cutpoint cutpoint = Cutpoint.getByNameSafe(extractCutpointString(ctx));
+    if (!IGNORE.equals(cutpoint)) {
+      // at this moment the underlying system doesn't support parametrized types in methods so we have to inform the user
+      checkForParametrizedTypesPresence(ctx);             // throws DropletFormatException if type params found
+    }
+    // as we consider constructor much like methods, let's firstly initialize it
+    TargetMethod constructor = new TargetMethod(constructorName, cutpoint, importsOnDemand);
 
     // There is no result type for constructors so we pass setting Method's result field. Proceed to formal parameters.
     DroppingJavaParser.FormalParameterListContext anyParams = ctx.formalParameterList();
-    storeMethodParams(method, anyParams);
+    storeMethodParams(constructor, anyParams);
 
-    // now that we know everything about the method we can store into targets map
-    targetsMap.put(composeCurrentKey(), method);
+    // now that we know everything about the constructor we can store it into targets map
+    targetsMap.put(composeCurrentKey(), constructor);
   }
 
   @Override
   public void enterMethodHeader(DroppingJavaParser.MethodHeaderContext ctx) {
-    // at this moment the underlying system doesn't support parametrized types in methods so we have to inform the user
-    checkForParametrizedTypesPresence(ctx);             // throws DropletFormatException if type params found
-    // first of all let's initialize this method itself
     DroppingJavaParser.MethodDeclaratorContext declarator = ctx.methodDeclarator();
-    TargetMethod method = new TargetMethod(declarator.Identifier().getText());
+    String methodName = declarator.Identifier().getText();
+
+    // let's start from extracting the cutpoint from preceding javadoc comment, if any
+    Cutpoint cutpoint = Cutpoint.getByNameSafe(extractCutpointString(ctx));
+    if (!IGNORE.equals(cutpoint)) {
+      // at this moment the underlying system doesn't support parametrized types in methods so we have to inform the user
+      checkForParametrizedTypesPresence(ctx);             // throws DropletFormatException if type params found
+    }
+    // first of all let's initialize this method itself
+    TargetMethod method = new TargetMethod(methodName, cutpoint, importsOnDemand);
 
     // store method's result type name
     DroppingJavaParser.ResultContext result = ctx.result();
@@ -150,12 +184,6 @@ public void enterMethodHeader(DroppingJavaParser.MethodHeaderContext ctx) {
     DroppingJavaParser.FormalParameterListContext anyParams = declarator.formalParameterList();
     storeMethodParams(method, anyParams);
 
-    // and finally let's extract the cutpoint from preceding javadoc comment, if any
-    String cutpointStr = extractCutpointString(ctx);
-    if (cutpointStr != null) {
-      method.setCutpoint(Cutpoint.valueOf(cutpointStr.toUpperCase()));
-    }
-
     // finally we can store the method in targets map
     targetsMap.put(composeCurrentKey(), method);
   }
@@ -210,7 +238,7 @@ private void storeMethodParams(TargetMethod method, DroppingJavaParser.FormalPar
 
   /**
    * Applies 2 modifications to given type name: (1) prepends it with package path according to
-   * {@link #importsMap} of this droplet; (2) converts it to {@link ClassLoader binary} name format, i.e. replaces
+   * {@link #singleImportsMap} of this droplet; (2) converts it to {@link ClassLoader binary} name format, i.e. replaces
    * dots in non-package part with dollar signs (e.g. turns {@code Map.Entry} to {@code Map$Entry}).
    * @param argumentType  original parameter or result type name as it was extracted from droplet parse tree
    * @return resolved name (may appear the same)
@@ -226,7 +254,7 @@ private String resolveMethodArgumentType(String argumentType) {
             ? argumentType.replaceAll("\\.", quoteReplacement("$"))
             : argumentType;
     // then we can search for corresponding import
-    String fqPrefix = importsMap.get(outerType);
+    String fqPrefix = singleImportsMap.get(outerType);
     return (fqPrefix == null)
             ? binaryName
             : (fqPrefix + "." + binaryName);
@@ -249,11 +277,10 @@ private String getPureTypeName(RuleContext typeCtx) {
    */
   private String extractCutpointString(ParserRuleContext ctx) {
     try {
-      /* Javadoc comments are neighbors to classBodyDeclaration, not the methodHeader so we have to find the ancestor.*/
-      ParserRuleContext classBodyDeclaration = ctx
-              .getParent()    // methodDeclaration
-              .getParent()    // classMemberDeclaration
-              .getParent();   // classBodyDeclaration
+      // Javadoc comments are neighbors to classBodyDeclaration, not the methodHeader so we have to find this anchor.
+      ParserRuleContext classBodyDeclaration = findJavadocAnchor(ctx);
+      if (classBodyDeclaration == null)       // this means the anchor was not found
+        return null;
       Token startToken = classBodyDeclaration.getStart();
       int startITokenIndex = startToken.getTokenIndex();
       // try to find out if there are any comments left to classBodyDeclaration
@@ -269,6 +296,7 @@ private String extractCutpointString(ParserRuleContext ctx) {
       JavadocLexer lexer = new JavadocLexer(inputStream);
       TokenStream tokenStream = new CommonTokenStream(lexer);
       JavadocParser parser = new JavadocParser(tokenStream);
+      parser.removeErrorListeners(); // javadoc is not strict format so we don't want to bother of its correctness here
       ParseTree tree = parser.documentation();
 
       // then find the actual needed value with dedicated listener
@@ -276,11 +304,11 @@ private String extractCutpointString(ParserRuleContext ctx) {
       ParseTreeWalker walker = new ParseTreeWalker();
       walker.walk(assembler, tree);
 
-      // and return found value (which eventually may be null)
+      // and return found value (which may eventually be null)
       return assembler.getTagValue();
 
     } catch (Exception e) {   // we can't be sure about anything in comments so that we need a defense line
-      System.out.printf("Couldn't extract cutpoint from javadoc comments: '%s'. Falling back to default.", e.getMessage());
+      System.out.printf("Couldn't extract cutpoint from javadoc comments: '%s'. Falling back to default.\n", e.getMessage());
       return null;
     }
   }
@@ -289,7 +317,7 @@ private String extractCutpointString(ParserRuleContext ctx) {
    * @return an actual key for targets map (composed basing on current state of the {@linkplain #classNameStack})
    */
   private String composeCurrentKey() {
-    StringBuilder sb = new StringBuilder(packageDeclaration);
+    StringBuilder sb = new StringBuilder(packageDeclaration.replaceAll("\\.", "/"));
     boolean first = true;
     for (Iterator<String> iterator = classNameStack.descendingIterator(); iterator.hasNext(); ) {
       String className = iterator.next();
@@ -298,17 +326,25 @@ private String composeCurrentKey() {
       } else {
         first = false;
       }
-      className = className.replaceFirst("(?i)_?Droplet$", "");
+      className = omitDropletSuffix(className);
       sb.append(className);
     }
 
     return sb.toString();
   }
 
+  /**
+   * @param className original droplet class name
+   * @return the {@code className} without last <i>Droplet</i> or <i>_Droplet</i> suffix
+   */
+  private String omitDropletSuffix(String className) {
+    return className.replaceFirst("(?i)_?Droplet$", "");
+  }
+
   /**
    * Replaces all the type names in {@code bodyText} with their fully qualified equivalents according to
-   * {@link #importsMap} of the droplet. Skips names that are already fully qualified.
-   * Does nothing if some type has no import.
+   * {@link #singleImportsMap} of the droplet. Skips names that are already fully qualified.
+   * Does nothing if a type has no import (leaving it for resolving during the instrumentation).
    * @param bodyText text of method's body being processed
    * @return the {@code bodyText} with fully qualified type names
    */
@@ -316,7 +352,7 @@ private String makeTypeNamesFullyQualified(String bodyText) {
     if (bodyText == null || bodyText.isEmpty())
       return bodyText;
     String processedText = bodyText;
-    for (Map.Entry<String, String> importEntry : importsMap.entrySet()) {
+    for (Map.Entry<String, String> importEntry : singleImportsMap.entrySet()) {
       String simpleName = importEntry.getKey();
       String fqName = importEntry.getValue() + "." + simpleName;
       Pattern pattern = Pattern.compile("(\\b)" + simpleName + "(\\b)");
@@ -349,7 +385,7 @@ private boolean isNameAlreadyQualified(String wholeText, int typeNameStartPositi
    * Replaces formal parameters references with symbolic equivalents according to Javassist notation (i.e. replaces
    * explicit names with ordinal links, for example {@code callMethod(someParam)} with {@code callMethod($1)}).
    * @param bodyText original method's body text
-   * @param formalParams  list of method's formal parameters
+   * @param formalParams ordered list of method's formal parameters
    * @return reformatted body text (may be the same as original)
    */
   private String obfuscateParameterReferences(String bodyText, List<Argument> formalParams) {
@@ -373,6 +409,14 @@ private String obfuscateParameterReferences(String bodyText, List<Argument> form
     return processedText;
   }
 
+  private DroppingJavaParser.ClassBodyDeclarationContext findJavadocAnchor(ParserRuleContext start) {
+    ParserRuleContext next = start;
+    while (!(next instanceof DroppingJavaParser.ClassBodyDeclarationContext) && next != null) {
+      next = next.getParent();
+    }
+    return (DroppingJavaParser.ClassBodyDeclarationContext) next;
+  }
+
   /**
    * Checks for presence of parametrized types in given rule context and throws DropletFormatException if finds.
    * Due to error in the original grammar this method doesn't detects generic types of formal parameters though the
@@ -396,9 +440,6 @@ public TargetsMap getTargetsMap() {
     return targetsMap;
   }
 
-  Map<String, String> getImportsMap() {
-    return importsMap;
-  }
   //endregion
 
 }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/UnderlineErrorListener.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/UnderlineErrorListener.java
index 2265972..17a1ca8 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/UnderlineErrorListener.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/UnderlineErrorListener.java
@@ -38,7 +38,7 @@ private String underlineError(Recognizer recognizer,
       return sb.append("\n").toString();
 
     } catch (Exception e) {
-      // Due to method bodies collapsing exact error symbol locating is not always possible, for example when the
+      // Due to method bodies collapsing, exact error symbol locating is not always possible, for example when the
       // offending symbol goes after collapsed body. In such cases we don't provide underlining (leaving it empty).
       return "\n";
     }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
index 8b53184..184ca82 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
@@ -4,37 +4,34 @@
 
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Set;
 
 /**
  * @author Toparvion
  */
 public class TargetMethod {
-  private String name;
-  private Cutpoint cutpoint = Cutpoint.INSTEAD;     // by default cutpoint is INSTEAD
+  private final String name;
+  private final Set<String> importsOnDemand;
+  private final Cutpoint cutpoint;
+
   private String text;
   private String resultType;
   private List<Argument> formalParams = new LinkedList<Argument>();
 
-  public TargetMethod(String name) {
+  public TargetMethod(String name, Cutpoint cutpoint, Set<String> importsOnDemand) {
     this.name = name;
+    this.cutpoint = cutpoint;
+    this.importsOnDemand = importsOnDemand;
   }
 
   public String getName() {
     return name;
   }
 
-  public void setName(String name) {
-    this.name = name;
-  }
-
   public Cutpoint getCutpoint() {
     return cutpoint;
   }
 
-  public void setCutpoint(Cutpoint cutpoint) {
-    this.cutpoint = cutpoint;
-  }
-
   public String getText() {
     return text;
   }
@@ -55,6 +52,10 @@ public void setResultType(String resultType) {
     this.resultType = resultType;
   }
 
+  public Set<String> getImportsOnDemand() {
+    return importsOnDemand;
+  }
+
   /**
    * <em>ATTENTION!</em> This method is actively used in unit tests result checking, therefore its changing may cause
    * many tests fail.
@@ -67,11 +68,12 @@ public String toString() {
             ", cutpoint=" + cutpoint +
             ", resultType=" + resultType +
             ", formalParams=" + listParamsToString(formalParams) +
+            (importsOnDemand.size()<2 ? "" : ",\n\t\timportsOnDemand="+listImportsToString(importsOnDemand)) +
             ", text=" + (text == null || text.isEmpty() ? "(empty)" : "\n\t\t"+text+"\n\t") +
             '}';
   }
 
-  private String listParamsToString(List<Argument> formalParams) {
+  private static String listParamsToString(List<Argument> formalParams) {
     StringBuilder sb = new StringBuilder("(");
     boolean isFirst = true;
     for (Argument argument: formalParams) {
@@ -88,4 +90,20 @@ private String listParamsToString(List<Argument> formalParams) {
     return sb.toString();
   }
 
+  private static String listImportsToString(Set<String> imports) {
+    StringBuilder sb = new StringBuilder("(");
+    boolean isFirst = true;
+    for (String anImport : imports) {
+      if (!isFirst) {
+        sb.append(", ");
+      } else {
+        isFirst = false;
+      }
+      sb.append(anImport);
+    }
+    sb.append(")");
+    return sb.toString();
+
+  }
+
 }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/modify/AfterBodyModifier.java b/src/main/java/ru/ftc/upc/testing/dropper/modify/AfterBodyModifier.java
index d375249..5d99f0a 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/modify/AfterBodyModifier.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/modify/AfterBodyModifier.java
@@ -1,8 +1,7 @@
 package ru.ftc.upc.testing.dropper.modify;
 
 import javassist.CannotCompileException;
-import javassist.CtMethod;
-import ru.ftc.upc.testing.dropper.Droplet;
+import javassist.CtBehavior;
 
 /**
  * Created by Toparvion on 29.04.2016 14:51
@@ -10,7 +9,7 @@
 public class AfterBodyModifier implements MethodModifier {
 
   @Override
-  public void apply(CtMethod method, Droplet droplet) throws CannotCompileException {
-    method.insertAfter(droplet.getText());
+  public void apply(CtBehavior method, String injection) throws CannotCompileException {
+    method.insertAfter(injection);
   }
 }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/modify/BeforeBodyModifier.java b/src/main/java/ru/ftc/upc/testing/dropper/modify/BeforeBodyModifier.java
index dd15eb2..616904e 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/modify/BeforeBodyModifier.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/modify/BeforeBodyModifier.java
@@ -1,8 +1,7 @@
 package ru.ftc.upc.testing.dropper.modify;
 
 import javassist.CannotCompileException;
-import javassist.CtMethod;
-import ru.ftc.upc.testing.dropper.Droplet;
+import javassist.CtBehavior;
 
 /**
  * Created by Toparvion on 29.04.2016 14:44
@@ -10,7 +9,7 @@
 public class BeforeBodyModifier implements MethodModifier {
 
   @Override
-  public void apply(CtMethod method, Droplet droplet) throws CannotCompileException {
-    method.insertBefore(droplet.getText());
+  public void apply(CtBehavior method, String injection) throws CannotCompileException {
+    method.insertBefore(injection);
   }
 }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/modify/InsteadBodyModifier.java b/src/main/java/ru/ftc/upc/testing/dropper/modify/InsteadBodyModifier.java
index eed6ca1..7246309 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/modify/InsteadBodyModifier.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/modify/InsteadBodyModifier.java
@@ -1,8 +1,7 @@
 package ru.ftc.upc.testing.dropper.modify;
 
 import javassist.CannotCompileException;
-import javassist.CtMethod;
-import ru.ftc.upc.testing.dropper.Droplet;
+import javassist.CtBehavior;
 
 /**
  * Created by Toparvion on 29.04.2016 14:45
@@ -10,7 +9,7 @@
 public class InsteadBodyModifier implements MethodModifier {
 
   @Override
-  public void apply(CtMethod method, Droplet droplet) throws CannotCompileException {
-    method.setBody(droplet.getText());
+  public void apply(CtBehavior method, String injection) throws CannotCompileException {
+    method.setBody(injection);
   }
 }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/modify/MethodModifier.java b/src/main/java/ru/ftc/upc/testing/dropper/modify/MethodModifier.java
index d5a169e..9f607c3 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/modify/MethodModifier.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/modify/MethodModifier.java
@@ -1,13 +1,12 @@
 package ru.ftc.upc.testing.dropper.modify;
 
 import javassist.CannotCompileException;
-import javassist.CtMethod;
-import ru.ftc.upc.testing.dropper.Droplet;
+import javassist.CtBehavior;
 
 /**
  * Created by Toparvion on 29.04.2016 14:38
  */
 public interface MethodModifier {
 
-  void apply(CtMethod method, Droplet droplet) throws CannotCompileException;
+  void apply(CtBehavior method, String injection) throws CannotCompileException;
 }
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/CutpointAssemblerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/CutpointAssemblerTest.java
index 8c73f25..ab066fb 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/CutpointAssemblerTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/CutpointAssemblerTest.java
@@ -64,6 +64,24 @@ public void cutpoint5IsRecognizedCorrectly() throws Exception {
     assertNull(tagValue);
   }
 
+  @Test
+  public void cutpoint6IsRecognizedCorrectly() throws Exception {
+    CutpointAssembler cutpointAssembler = loadJavadoc("src/test/resources/Cutpoint_6.javadoc");
+    String tagValue = cutpointAssembler.getTagValue();
+    Cutpoint cutpoint = Cutpoint.valueOf(tagValue.toUpperCase());
+    System.out.printf("Cutpoint 6: '%s'\n", tagValue);
+    assertEquals(Cutpoint.IGNORE, cutpoint);
+  }
+
+  @Test
+  public void cutpoint7IsRecognizedCorrectly() throws Exception {
+    CutpointAssembler cutpointAssembler = loadJavadoc("src/test/resources/Cutpoint_7.javadoc");
+    String tagValue = cutpointAssembler.getTagValue();
+    Cutpoint cutpoint = Cutpoint.valueOf(tagValue.toUpperCase());
+    System.out.printf("Cutpoint 7: '%s'\n", tagValue);
+    assertEquals(Cutpoint.IGNORE, cutpoint);
+  }
+
   private CutpointAssembler loadJavadoc(String javadocPath) throws IOException {
     ANTLRFileStream fileStream = new ANTLRFileStream(javadocPath);
     JavadocLexer lexer = new JavadocLexer(fileStream);
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
index 7585755..75e2527 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
@@ -28,7 +28,7 @@ public void nestedClassesAreRecognizedFully() throws Exception {
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     System.out.println(actual);
-    String expected = "ru.ftc.upc.testing.dropper.lang.samples.MultiNestedClasses -> {\n" +
+    String expected = "ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 1 ;\n" +
             "\t}\n" +
@@ -39,7 +39,7 @@ public void nestedClassesAreRecognizedFully() throws Exception {
             "\t\treturn 7 ;\n" +
             "\t}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.samples.MultiNestedClasses$InnerClass1 -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses$InnerClass1 -> {\n" +
             "\tTargetMethod{name='method2', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 2 ;\n" +
             "\t}\n" +
@@ -47,12 +47,12 @@ public void nestedClassesAreRecognizedFully() throws Exception {
             "\t\treturn 3 ;\n" +
             "\t}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.samples.MultiNestedClasses$InnerClass2 -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses$InnerClass2 -> {\n" +
             "\tTargetMethod{name='method5', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 5 ;\n" +
             "\t}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.samples.MultiNestedClasses$InnerClass2$InnerClass3 -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses$InnerClass2$InnerClass3 -> {\n" +
             "\tTargetMethod{name='method6', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\treturn 6 ;\n" +
             "\t}\n" +
@@ -66,7 +66,7 @@ public void methodHeadersAreRecognizedFully() throws Exception {
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     System.out.println(actual);
-    String expected = "ru.ftc.upc.testing.dropper.lang.samples.VariousMethodHeaders -> {\n" +
+    String expected = "ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders -> {\n" +
             "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(), text=(empty)}\n" +
             "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(java.util.Stack param1), text=(empty)}\n" +
             "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(float arg), text=(empty)}\n" +
@@ -83,7 +83,7 @@ public void methodHeadersAreRecognizedFully() throws Exception {
             "\t\treturn java.util.Collections . emptySet ( ) ;\n" +
             "\t}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.samples.VariousMethodHeaders$InnerClass -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders$InnerClass -> {\n" +
             "\tTargetMethod{name='InnerClass', cutpoint=INSTEAD, resultType=null, formalParams=(java.util.Deque arg), text=(empty)}\n" +
             "}\n";
     assertEquals(expected, actual);
@@ -95,7 +95,7 @@ public void methodBodiesAreRecognizedFully() throws Exception {
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     System.out.println(actual);
-    String expected = "ru.ftc.upc.testing.dropper.lang.samples.MethodBodies -> {\n" +
+    String expected = "ru/ftc/upc/testing/dropper/lang/samples/MethodBodies -> {\n" +
             "\tTargetMethod{name='MethodBodies', cutpoint=INSTEAD, resultType=null, formalParams=(String name), text=\n" +
             "\t\tSystem . out . println ( \"Hello from constructor :) \" ) ;\n" +
             "\t}\n" +
@@ -113,7 +113,7 @@ public void enumTypesAreRecognizedFully() throws Exception {
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     System.out.println(actual);
-    String expected = "ru.ftc.upc.testing.dropper.lang.samples.RootEnumeration -> {\n" +
+    String expected = "ru/ftc/upc/testing/dropper/lang/samples/RootEnumeration -> {\n" +
             "\tTargetMethod{name='RootEnumeration', cutpoint=INSTEAD, resultType=null, formalParams=(), text=\n" +
             "\t\tString nothing = \"I'm the most enumerated constructor ever!\" ;\n" +
             "\t}\n" +
@@ -121,7 +121,7 @@ public void enumTypesAreRecognizedFully() throws Exception {
             "\t\tfor ( RootEnumeration rootEnum : values ( ) ) { if ( rootEnum . toString ( ) . equals ( $1 ) ) { return rootEnum ; } } throw new IllegalArgumentException ( \"Not found: \" + $1 ) ;\n" +
             "\t}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.samples.RootEnumeration$InnerEnum -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/samples/RootEnumeration$InnerEnum -> {\n" +
             "\tTargetMethod{name='isTheSame', cutpoint=INSTEAD, resultType=boolean, formalParams=(Enum e), text=\n" +
             "\t\treturn INNER_ENUM . toString ( ) . equals ( $1 . toString ( ) ) ;\n" +
             "\t}\n" +
@@ -135,7 +135,7 @@ public void interfaceTypesAreRecognizedFully() throws Exception {
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     System.out.println(actual);
-    String expected = "ru.ftc.upc.testing.dropper.lang.RootInterface -> {\n" +
+    String expected = "ru/ftc/upc/testing/dropper/lang/RootInterface -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "\tTargetMethod{name='method2', cutpoint=INSTEAD, resultType=boolean, formalParams=(int two), text=(empty)}\n" +
             "\tTargetMethod{name='method3', cutpoint=INSTEAD, resultType=RootInterface, formalParams=(java.util.Set longs), text=(empty)}\n" +
@@ -146,12 +146,12 @@ public void interfaceTypesAreRecognizedFully() throws Exception {
             "\t\treturn new java.util.Observable ( ) ;\n" +
             "\t}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.RootInterface$InnerIface -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/RootInterface$InnerIface -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=java.io.InputStream, formalParams=(), text=\n" +
             "\t\treturn new java.io.FileInputStream ( \"\" ) ;\n" +
             "\t}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.RootInterface$InnerIface$InnerInnerIface -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/RootInterface$InnerIface$InnerInnerIface -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=java.io.OutputStream, formalParams=(), text=\n" +
             "\t\treturn new java.io.FileOutputStream ( \"\" ) ;\n" +
             "\t}\n" +
@@ -165,38 +165,38 @@ public void typesCombinationsAreRecognizedFully() throws Exception {
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     System.out.println(actual);
-    String expected = "ru.ftc.upc.testing.dropper.lang.samples.TypesCombination -> {\n" +
+    String expected = "ru/ftc/upc/testing/dropper/lang/samples/TypesCombination -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=\n" +
             "\t\tSystem . console ( ) ;\n" +
             "\t}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.samples.TypesCombination$InnerInterface -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/samples/TypesCombination$InnerInterface -> {\n" +
             "\tTargetMethod{name='innerMethod', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.samples.TypesCombination$InnerInterface$InnerInnerClass -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/samples/TypesCombination$InnerInterface$InnerInnerClass -> {\n" +
             "\tTargetMethod{name='innerInnerMethod', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.samples.TypesCombination$InnerInterface$InnerInnerClass$InnerInnerInnerEnum -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/samples/TypesCombination$InnerInterface$InnerInnerClass$InnerInnerInnerEnum -> {\n" +
             "\tTargetMethod{name='doSomething', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.samples.SiblingClass -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/samples/SiblingClass -> {\n" +
             "\tTargetMethod{name='method', cutpoint=INSTEAD, resultType=double, formalParams=(), text=\n" +
             "\t\treturn Math . random ( ) ;\n" +
             "\t}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.samples.SiblingEnum -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/samples/SiblingEnum -> {\n" +
             "\tTargetMethod{name='SiblingEnum', cutpoint=INSTEAD, resultType=null, formalParams=(), text=(empty)}\n" +
             "\tTargetMethod{name='getMe', cutpoint=INSTEAD, resultType=SiblingEnum, formalParams=(), text=\n" +
             "\t\treturn this ;\n" +
             "\t}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.samples.SiblingEnum$InnerInterface -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/samples/SiblingEnum$InnerInterface -> {\n" +
             "\tTargetMethod{name='getThatEnum', cutpoint=INSTEAD, resultType=TypesCombination$InnerInterface$InnerInnerClass$InnerInnerInnerEnum, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.samples.SiblingInterface -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/samples/SiblingInterface -> {\n" +
             "\tTargetMethod{name='method', cutpoint=INSTEAD, resultType=java.util.Vector, formalParams=(java.util.Vector arg), text=(empty)}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.samples.SiblingInterface$InnerEnum -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/samples/SiblingInterface$InnerEnum -> {\n" +
             "\tTargetMethod{name='InnerEnum', cutpoint=INSTEAD, resultType=null, formalParams=(), text=(empty)}\n" +
             "}\n";
     assertEquals(expected, actual);
@@ -205,21 +205,26 @@ public void typesCombinationsAreRecognizedFully() throws Exception {
   @Test
   public void importMapIsComposedCorrectly() throws Exception {
     String dropletPath = "src/test/resources/Imports.java";
-    Map<String, String> importsMap = loadDroplet(dropletPath).getImportsMap();
-    String expected = "\tCurrency -> java.util\n" +
-            "\tBASE64Encoder -> sun.misc\n";
-    String actual = map2Str(importsMap);
-    System.out.println(actual);
-    assertEquals(expected, actual);
-  }
-
-  @Test(expected = DropletFormatException.class)
-  public void importsOnDemandAreNotSupported() throws Exception {
-    String dropletPath = "src/test/resources/FaultyImports.java";
-    Map<String, String> importsMap = loadDroplet(dropletPath).getImportsMap();
+    DropletAssembler dropletAssembler = loadDroplet(dropletPath);
+    Map<String, String> importsMap = dropletAssembler.singleImportsMap;
+    String expectedImportsMap = "\tCurrency -> java.util\n" +
+            "\tBASE64Encoder -> sun.misc\n" +
+            "\tMAX_VALUE -> java.lang.Integer\n" +
+            "\trandom -> java.lang.Math\n";
+    String actualImportsMap = map2Str(importsMap);
+    System.out.println(actualImportsMap);
+    assertEquals(expectedImportsMap, actualImportsMap);
 
-    String actual = map2Str(importsMap);
-    System.out.println(actual);
+    TargetsMap targetsMap = dropletAssembler.getTargetsMap();
+    String actualTargetsMap = targetsMap.toString();
+    System.out.println(actualTargetsMap);
+    String expectedTargetsMap = "ru/ftc/upc/testing/dropper/lang/samples/Imports -> {\n" +
+            "\tTargetMethod{name='Imports', cutpoint=INSTEAD, resultType=null, formalParams=(),\n" +
+            "\t\timportsOnDemand=(ru.ftc.upc.testing.dropper.lang.samples, java.math), text=\n" +
+            "\t\tSystem . out . println ( ) ; BigInteger bigInteger = new BigInteger ( \"31415926525\" ) ; double java.lang.Math.random = java.lang.Math.random ( ) ; int maxInt = java.lang.Integer.MAX_VALUE ; System . out . printf ( \"%d, %d, %d\" , MAX_EXPONENT , MIN_EXPONENT , MIN_VALUE ) ;\n" +
+            "\t}\n" +
+            "}\n";
+    assertEquals(expectedTargetsMap, actualTargetsMap);
   }
 
   @Test
@@ -246,7 +251,7 @@ public void typeNamesInMethodBodiesAreResolvedCorrectly() throws Exception {
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     System.out.println(actual);
-    String expected = "dp.DPClientImpl -> {\n" +
+    String expected = "dp/DPClientImpl -> {\n" +
             "\tTargetMethod{name='currencyRate', cutpoint=INSTEAD, resultType=dp.models.QuickPay$AnsCurrencyRate, formalParams=(dp.models.QuickPay$ReqCurrencyRate reqCurrencyRate), text=\n" +
             "\t\ttry { java.io.FileReader stubReader = new java.io.FileReader ( System . getProperty ( \"user.dir\" ) + java.io.File . separator + \"AnsCurrencyRate.xml\" ) ; javax.xml.bind.Unmarshaller unmarshaller = quickPayJbcDoc . createUnmarshaller ( ) ; dp.models.QuickPay quickPay = ( dp.models.QuickPay ) unmarshaller . unmarshal ( stubReader ) ; log . info ( \"Rates were loaded from file AnsCurrencyRate.xml.\" ) ; stubReader . close ( ) ; return quickPay . getInfoService ( ) . getAnsCurrencyRate ( ) ; } catch ( Exception e ) { log . error ( \"Unable to load rates from file. Falling back to real service.\" , e ) ; dp . models . QuickPay quickPay = dp.models.QuickPay . infoService ( ) ; quickPay . getInfoService ( ) . setReqCurrencyRate ( $1 ) ; quickPay = sendQuickPay ( quickPay , false , false ) ; dp.models.QuickPay . AnsCurrencyRate ans = quickPay . getInfoService ( ) . getAnsCurrencyRate ( ) ; return ans ; }\n" +
             "\t}\n" +
@@ -261,7 +266,7 @@ public void methodArgumentTypesAreResolvedCorrectly() throws Exception {
     String actual = targetsMap.toString();
     System.out.println(actual);
 
-    String expected = "ru.ftc.upc.testing.dropper.lang.samples.NestedTypesAmongMethodArguments -> {\n" +
+    String expected = "ru/ftc/upc/testing/dropper/lang/samples/NestedTypesAmongMethodArguments -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=java.util.Map$Entry, formalParams=(java.security.KeyStore$SecretKeyEntry arg), text=\n" +
             "\t\treturn new java.util.AbstractMap . SimpleEntry < Long , String > ( 23L , \"\" ) ;\n" +
             "\t}\n" +
@@ -275,7 +280,7 @@ public void formalParamReferencesAreObfuscatedCorrectly() throws Exception {
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     System.out.println(actual);
-    String expected = "dp.DPClientImpl -> {\n" +
+    String expected = "dp/DPClientImpl -> {\n" +
             "\tTargetMethod{name='fetchTransferStatus', cutpoint=INSTEAD, resultType=String, formalParams=(String oID, boolean needFlag), text=\n" +
             "\t\tString statusStr = null ; try { java.util.Properties stub = new java.util.Properties ( ) ; stub . load ( new java.io.FileReader ( System . getProperty ( \"user.dir\" ) + java.io.File . separator + \"dp-edit-mock.properties\" ) ) ; statusStr = stub . getProperty ( $1 ) ; if ( statusStr != null ) { statusStr = statusStr . trim ( ) ; log . warn ( \"For STRoID={} transfer status '{}' was taken from mock.\" , $1 , statusStr ) ; } } catch ( java.io.IOException e ) { log . error ( \"Failed to load mocked transfer edit statuses.\" , e ) ; } if ( statusStr == null ) { dp.models.QuickPay quickPay = dp.models.QuickPay . infoService ( ) ; dp.models.ReqTransferSearch req = new dp.models.ReqTransferSearch ( ) ; req . setOID ( getReserve ( ) . oID ) ; quickPay . getInfoService ( ) . setReqTransferSearch ( req ) ; quickPay = sendQuickPay ( quickPay , false , $2 ) ; statusStr = quickPay . getInfoService ( ) . getAnsTransferSearch ( ) . getTransferStatus ( ) ; } return statusStr ;\n" +
             "\t}\n" +
@@ -290,19 +295,19 @@ public void dropletSuffixIsOmittedCorrectly() throws Exception {
     String actual = targetsMap.toString();
     System.out.println(actual);
 
-    String expected = "ru.ftc.upc.testing.dropper.lang.samples.ClassWithSuffix -> {\n" +
+    String expected = "ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffix -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.samples.ClassWithSuffix$InnerClass -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffix$InnerClass -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.samples.ClassWithSuffix$InnerClass2 -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffix$InnerClass2 -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.samples.ClassWithSuffix$InnerClassDropletNotLatest -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffix$InnerClassDropletNotLatest -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "ru.ftc.upc.testing.dropper.lang.samples.ClassWithSuffix$InnerClassDroplet -> {\n" +
+            "ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffix$InnerClassDroplet -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n";
     assertEquals(expected, actual);
diff --git a/src/test/resources/Cutpoint_6.javadoc b/src/test/resources/Cutpoint_6.javadoc
new file mode 100644
index 0000000..5f5c71d
--- /dev/null
+++ b/src/test/resources/Cutpoint_6.javadoc
@@ -0,0 +1,8 @@
+/**
+ * Returns boolean.
+ *
+ * @param b	the boolean
+ * @cutpoint IGNORE
+ * @return the string
+ * @since 1.4
+ */
\ No newline at end of file
diff --git a/src/test/resources/Cutpoint_7.javadoc b/src/test/resources/Cutpoint_7.javadoc
new file mode 100644
index 0000000..7cdc4f0
--- /dev/null
+++ b/src/test/resources/Cutpoint_7.javadoc
@@ -0,0 +1 @@
+/** @cutpoint IGNORE */
\ No newline at end of file
diff --git a/src/test/resources/DrawPaneDroplet.java b/src/test/resources/DrawPaneDroplet.java
new file mode 100644
index 0000000..c056f5d
--- /dev/null
+++ b/src/test/resources/DrawPaneDroplet.java
@@ -0,0 +1,39 @@
+/**
+ *
+ */
+package lab3;
+
+import javax.swing.*;
+import java.util.*;
+
+/**
+ * @author Toparvion
+ */
+public class DrawPaneDroplet extends JComponent implements Runnable {
+
+  /**
+   *
+   * @param indicator
+   * @param points
+   * @param parent
+   * @cutpoint BEFORE
+   */
+  public DrawPaneDroplet(JProgressBar indicator, int points, Painter parent) {
+    System.out.println("UUID: " + UUID.randomUUID().toString());
+    System.out.println("Parent component size is " + parent.getSize().toString());
+  }
+
+  /**
+   * @cutpoint IGNORE
+   */
+  public void run() {
+    long times = 0;
+    times++;
+    try {
+      Thread.sleep(10);
+    } catch (InterruptedException e) {
+      e.printStackTrace();
+    }
+  }
+
+}
diff --git a/src/test/resources/FaultyImports.java b/src/test/resources/FaultyImports.java
deleted file mode 100644
index 4cab3aa..0000000
--- a/src/test/resources/FaultyImports.java
+++ /dev/null
@@ -1,13 +0,0 @@
-package ru.ftc.upc.testing.dropper.lang.samples;
-
-import java.util.Currency;
-import Object;
-import sun.misc.BASE64Encoder;
-import java.applet.*;           // the reason of test fail
-
-class Imports {
-
-  public FaultyImports() {
-    System.out.println();
-  }
-}
\ No newline at end of file
diff --git a/src/test/resources/Imports.java b/src/test/resources/Imports.java
index 8b64ada..0d3ee00 100644
--- a/src/test/resources/Imports.java
+++ b/src/test/resources/Imports.java
@@ -3,10 +3,19 @@
 import java.util.Currency;
 import Object;                  // must be ignored by assembler
 import sun.misc.BASE64Encoder;
+import java.math.*;
+
+import static java.lang.Double.*;
+import static java.lang.Integer.MAX_VALUE;
+import static java.lang.Math.random;
 
 class Imports {
 
   public Imports() {
     System.out.println();
+    BigInteger bigInteger = new BigInteger("31415926525");
+    double random = random();
+    int maxInt = MAX_VALUE;
+    System.out.printf("%d, %d, %d", MAX_EXPONENT, MIN_EXPONENT, MIN_VALUE);
   }
 }
\ No newline at end of file

From 8cc108584dc339a96ce67e915fd879280cca04d6 Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Wed, 6 Jul 2016 23:15:08 +0600
Subject: [PATCH 17/22] Javassistification. Part 2. + added sample standalone
 Swing application and a couple of droplets for it; + added a couple of
 droplets to test instrumentation of classes run under Tomcat servlet
 container.

---
 build.gradle                                  |  16 +-
 .../ru/ftc/upc/testing/dropper/Droplet.java   |  60 ---
 .../ftc/upc/testing/dropper/DropperAgent.java | 115 +----
 .../testing/dropper/PatchingTransformer.java  |  49 +-
 .../dropper/lang/DropletAssembler.java        |  27 +-
 .../lang/PureTypeNameComposingVisitor.java    |   5 +-
 .../upc/testing/dropper/model/DropletV2.java  |  23 -
 .../testing/dropper/model/TargetMethod.java   |   2 +-
 .../dropper/lang/DropletAssemblerTest.java    |  94 ++--
 .../lang/samples/VariousMethodHeaders.java    |  24 +-
 .../standalone/painter/DrawPane.java          | 151 ++++++
 .../standalone/painter/DrawPaneDroplet.java   |  54 +++
 .../sampleapp/standalone/painter/Painter.java | 429 ++++++++++++++++++
 .../standalone/painter/PainterApplet.java     |  15 +
 .../standalone/painter/PainterDroplet.java    |  94 ++++
 .../standalone/painter/package-info.java      |   7 +
 src/test/resources/DrawPaneDroplet.java       |  39 --
 src/test/resources/JFrameDroplet.java         |  14 +
 .../resources/RequestInfoExampleDroplet.java  |  55 +++
 src/test/resources/Room.java                  |  77 ++++
 20 files changed, 1041 insertions(+), 309 deletions(-)
 delete mode 100644 src/main/java/ru/ftc/upc/testing/dropper/Droplet.java
 delete mode 100644 src/main/java/ru/ftc/upc/testing/dropper/model/DropletV2.java
 create mode 100644 src/test/java/sampleapp/standalone/painter/DrawPane.java
 create mode 100644 src/test/java/sampleapp/standalone/painter/DrawPaneDroplet.java
 create mode 100644 src/test/java/sampleapp/standalone/painter/Painter.java
 create mode 100644 src/test/java/sampleapp/standalone/painter/PainterApplet.java
 create mode 100644 src/test/java/sampleapp/standalone/painter/PainterDroplet.java
 create mode 100644 src/test/java/sampleapp/standalone/painter/package-info.java
 delete mode 100644 src/test/resources/DrawPaneDroplet.java
 create mode 100644 src/test/resources/JFrameDroplet.java
 create mode 100644 src/test/resources/RequestInfoExampleDroplet.java
 create mode 100644 src/test/resources/Room.java

diff --git a/build.gradle b/build.gradle
index e98edb4..3e81996 100644
--- a/build.gradle
+++ b/build.gradle
@@ -4,6 +4,7 @@ version '1.0'
 apply plugin: 'java'
 
 sourceCompatibility = 1.6
+compileTestJava.options.encoding = 'UTF-8'
 
 repositories {
     mavenCentral()
@@ -17,7 +18,6 @@ configurations {
 dependencies {
     compile 'org.javassist:javassist:3.20.0-GA'
     compile 'org.slf4j:slf4j-api:1.7.7'
-    // http://mvnrepository.com/artifact/org.antlr/antlr4-runtime
     compile group: 'org.antlr', name: 'antlr4-runtime', version: '4.5.3'
     testCompile group: 'junit', name: 'junit', version: '4.11'
 }
@@ -29,9 +29,21 @@ jar {
                 "Premain-Class": "ru.ftc.upc.testing.dropper.DropperAgent",
                 "Main-Class": "ru.ftc.upc.testing.dropper.DropletChecker")
     }
-
     from {
         (configurations.runtime - configurations.provided)
                 .collect({ it.isDirectory() ? it : zipTree(it) })
     }
+    exclude ('**/*.g4')  // there is no need to export grammar files as they are already exported via generated parsers
+}
+
+task runPainterWithDebug(type: JavaExec, dependsOn: jar) {
+    classpath = sourceSets.test.runtimeClasspath
+    main 'sampleapp.standalone.painter.Painter'
+    jvmArgs = ['-Dfile.encoding=UTF8',
+               '-javaagent:build/libs/dropper-1.0.jar=' +
+                       'src/test/java/sampleapp/standalone/painter/DrawPaneDroplet.java;' +
+                       'src/test/java/sampleapp/standalone/painter/PainterDroplet.java;' +
+                       'src/test/resources/JFrameDroplet.java'
+    ].toList()
+    debug = true            // Gradle default debug port is 5005
 }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/Droplet.java b/src/main/java/ru/ftc/upc/testing/dropper/Droplet.java
deleted file mode 100644
index 0b32f28..0000000
--- a/src/main/java/ru/ftc/upc/testing/dropper/Droplet.java
+++ /dev/null
@@ -1,60 +0,0 @@
-package ru.ftc.upc.testing.dropper;
-
-/**
- * Created by Toparvion on 29.04.2016 11:58
- */
-public class Droplet {
-  private String clazz;
-  private String method;
-  private Cutpoint cutpoint;
-  private String text;
-
-  public String getClazz() {
-    return clazz;
-  }
-
-  public void setClazz(String clazz) {
-    this.clazz = clazz;
-  }
-
-  public String getMethod() {
-    return method;
-  }
-
-  public void setMethod(String method) {
-    this.method = method;
-  }
-
-  public Cutpoint getCutpoint() {
-    return cutpoint;
-  }
-
-  public void setCutpoint(Cutpoint cutpoint) {
-    this.cutpoint = cutpoint;
-  }
-
-  public String getText() {
-    return text;
-  }
-
-  public void setText(String text) {
-    this.text = text;
-  }
-
-  public String getMissedField() {
-    if (clazz == null) return "class";
-    if (method == null) return "method";
-    if (cutpoint == null) return "cutpoint";
-    if (text == null) return "text";
-    return null;
-  }
-
-  @Override
-  public String toString() {
-    return "Droplet{" +
-            "clazz='" + clazz + '\'' +
-            ", method='" + method + '\'' +
-            ", cutpoint=" + cutpoint +
-            "}; text=\n" + text;
-  }
-}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java b/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java
index 2138bad..4ec1a35 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java
@@ -1,30 +1,14 @@
 package ru.ftc.upc.testing.dropper;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import ru.ftc.upc.testing.dropper.model.TargetsMap;
 
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileReader;
-import java.io.IOException;
 import java.lang.instrument.Instrumentation;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import static java.lang.String.format;
 
 /**
  * Created by Toparvion on 28.04.2016 9:13
  */
-@SuppressWarnings("unused")
+@SuppressWarnings({"unused", "WeakerAccess"}) // the class is used by Java Instrumentation API and thus must be public
 public class DropperAgent {
-  private static final Logger log = LoggerFactory.getLogger("Dropper");
-
-  private static final String DROPLET_LINE_PREFIX = "//droplet";
 
   public static void premain(String agentArgs, Instrumentation inst) {
     System.out.println(DROPPER_LOGO);
@@ -44,103 +28,6 @@ public static void premain(String agentArgs, Instrumentation inst) {
     }
   }
 
-  private static Set<Droplet> getDroplets(String args) {
-    if (args == null || "".equals(args)) return Collections.emptySet();
-
-    Set<Droplet> droplets = new HashSet<Droplet>();
-    String[] argTokens = args.split(";");
-    for (String token : argTokens) {
-      try {
-        File dropletFile = new File(token);
-        if (!dropletFile.canRead()) {
-          log.warn("Droplet '{}' can not be read by the agent.", token);
-          continue;
-        }
-
-        Droplet droplet = loadDroplet(dropletFile);
-        droplets.add(droplet);
-
-      } catch (Exception e) {
-        log.error(format("Failed to load droplet '%s'.", token), e);
-      }
-    }
-    return droplets;
-  }
-
-  private static Droplet loadDroplet(File dropletFile) throws Exception {
-    FileReader fileReader = new FileReader(dropletFile);
-    BufferedReader bufferedReader = new BufferedReader(fileReader);
-
-    // заготовка дроплета для заполнения
-    Droplet droplet = new Droplet();
-
-    String line;
-    // основной обход файла дроплета
-    while ((line = bufferedReader.readLine()) != null) {
-      if (!line.startsWith(DROPLET_LINE_PREFIX)) {
-        continue;
-      }
-      String entryValue;
-
-      // проверка на класс
-      entryValue = getEntryValue(line, "class");
-      if (entryValue != null) {
-        droplet.setClazz(entryValue);
-        continue;
-      }
-
-      // проверка на метод
-      entryValue = getEntryValue(line, "method");
-      if (entryValue != null) {
-        droplet.setMethod(entryValue);
-        continue;
-      }
-
-      // проверка на точку подключения
-      entryValue = getEntryValue(line, "cutpoint");
-      if (entryValue != null) {
-        Cutpoint cutpoint = Cutpoint.valueOf(entryValue);
-        droplet.setCutpoint(cutpoint);
-        continue;
-      }
-
-      // проверка на текст дроплета
-      entryValue = getEntryValue(line, "text");
-      if (entryValue != null) {
-        String text = loadDropletText(bufferedReader);
-        droplet.setText(text);
-        break;      // текст предполагается в конце дроплета, поэтому читать дальше смысла уже нет
-      }
-    }
-    bufferedReader.close();
-
-    // убедимся, что все "запчасти" дроплета были считаны
-    String missedField = droplet.getMissedField();
-    if (missedField != null) throw new IllegalArgumentException(format("Droplet doesn't contain field '%s' or it " +
-            "is not correctly formatted.", missedField));
-
-    return droplet;
-  }
-
-  private static String getEntryValue(String line, String entryKey) {
-    Pattern pattern = Pattern.compile(entryKey + ":[\\x20\\t]*(\\p{Graph}*)", Pattern.CASE_INSENSITIVE);
-    Matcher matcher = pattern.matcher(line);
-    if (matcher.find()) {
-      return matcher.group(1);
-    } else {
-      return null;
-    }
-  }
-
-  private static String loadDropletText(BufferedReader bufferedReader) throws IOException {
-    StringBuilder sb = new StringBuilder();
-    String line;
-    while ((line = bufferedReader.readLine()) != null) {
-      sb.append(line).append("\n");
-    }
-    return sb.toString();
-  }
-
   //<editor-fold desc="Logo">
   private static final String DROPPER_LOGO =
     "     _____                                     \n" +
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java b/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java
index 4a5a83d..8e638e2 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java
@@ -18,6 +18,12 @@
  * Created by Toparvion on 29.04.2016 12:50
  */
 class PatchingTransformer implements ClassFileTransformer {
+  /**
+   * The package that is implicitly imported into every Javassist ClassPool instance and therefore should be considered
+   * known while resolving formal parameters' FQ names.
+   */
+  private static final String DEFAULT_PACKAGE = "java.lang";
+
   private ClassPool pool;
   private final TargetsMap targetsMap;
   private final Set<ClassLoader> knownLoaders = new HashSet<ClassLoader>();
@@ -40,8 +46,12 @@ public byte[] transform(ClassLoader loader,
     }
     // this class is of interest, so let's try to modify it
     try {
-      if (knownLoaders.add(loader)) {           // TODO avoid explicit loaders comparison
+      // but before, let's store the class loader if it is a new one for us
+      if ((loader != null)
+              && !loader.getClass().getName().contains("sun.misc.DelegatingClassLoader")
+              && knownLoaders.add(loader)) {
         ClassPool childPool = new ClassPool(pool);
+        childPool.insertClassPath(new LoaderClassPath(loader));
         childPool.childFirstLookup = true;
         pool = childPool;
       }
@@ -52,6 +62,10 @@ public byte[] transform(ClassLoader loader,
       pool.insertClassPath(new ByteArrayClassPath(dottedClassName, classFileBuffer));
       CtClass ctClass = pool.get(dottedClassName);
 
+      // in order to include the containing package into CtClass search scope we explicitly extract it from class name
+      String localPackage = dottedClassName.contains(".")
+              ? dottedClassName.substring(0, dottedClassName.lastIndexOf('.'))
+              : null;
       // iterate over desired methods trying to modify each one
       for (TargetMethod targetMethod : targetMethods) {
         try {
@@ -59,8 +73,11 @@ public byte[] transform(ClassLoader loader,
             System.out.printf("Method '%s#%s' is skipped due to IGNORE cutpoint.\n", dottedClassName, targetMethod.getName());
             continue;
           }
-          // in order to precisely select method to modify we need CtClass representation of all its parameters
-          CtClass[] argsArray = javassistifyArguments(targetMethod.getFormalParams(), targetMethod.getImportsOnDemand());
+          // in order to precisely select method to modify we need CtClass representation of all its formal parameters
+          CtClass[] argsArray = javassistifyArguments(
+                  targetMethod.getFormalParams(),
+                  targetMethod.getImportsOnDemand(),
+                  localPackage);
 
           // pick javassist representation of target method
           CtBehavior ctMethod = (targetMethod.getResultType() != null)        // constructors do not have result type
@@ -94,15 +111,33 @@ public byte[] transform(ClassLoader loader,
     }
   }
 
-  private CtClass[] javassistifyArguments(List<Argument> args, Set<String> importsOnDemand) throws NotFoundException {
+  /**
+   * Initializes Javassist CtClass representations for all given arguments. This is required for precise selecting of
+   * the method to modify - Javassist must know all its formal parameters as CtClass objects.
+   * @param args arguments of target method
+   * @param importsOnDemand a set of imports on demand (needed during searching for CtClass objects)
+   * @param localPackage full name of a package containing target class (used in param names resolving)
+   * @return an array of CtClass objects representing all given arguments
+   * @throws NotFoundException if some of arguments can not be represented as CtClass object
+   */
+  private CtClass[] javassistifyArguments(List<Argument> args, Set<String> importsOnDemand, String localPackage)
+          throws NotFoundException {
+    // the actual import set is an extension to the given one: it also includes default and local packages
+    Set<String> extendedImports = new HashSet<String>(importsOnDemand);
+    extendedImports.add(DEFAULT_PACKAGE);
+    if (localPackage != null)
+      extendedImports.add(localPackage);
+
     List<CtClass> argCtClasses = new ArrayList<CtClass>(args.size());
     for (Argument arg : args) {
+      // the first, 'naive' attempt is taken to resolve a parameter of primitive type
       String argumentTypeName = arg.getType();
       CtClass argumentCtClass = pool.getOrNull(argumentTypeName);
-      // if this arg has not been found in the pool, let's try to prepend its name with various imports on demand
+      // if it fails, let's try to prepend param name with various imports on demand (including implicit ones)
       if (argumentCtClass == null) {
-        for (String importEntry : importsOnDemand) {
-          argumentCtClass = pool.getOrNull(importEntry + "." + arg.getType());
+        for (String importEntry : extendedImports) {
+          String supposedFqName = importEntry + "." + arg.getType();
+          argumentCtClass = pool.getOrNull(supposedFqName);
           if (argumentCtClass != null) {
             break;
           }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
index 3676aca..31b6465 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
@@ -70,8 +70,6 @@ public void enterPackageDeclaration(DroppingJavaParser.PackageDeclarationContext
       sb.append(idNode.getText()).append(".");
     }
     this.packageDeclaration = sb.toString();
-    // the very first import on demand is the containing package itself (used later to 'javassistify' formal parameters)
-    this.importsOnDemand.add(sb.substring(0, sb.length()-1));
   }
 
   @Override
@@ -174,7 +172,7 @@ public void enterMethodHeader(DroppingJavaParser.MethodHeaderContext ctx) {
 
     // store method's result type name
     DroppingJavaParser.ResultContext result = ctx.result();
-    String resultType = getPureTypeName(result);
+    String resultType = extractPureTypeName(result);
     if (!"void".equals(resultType)) {           // avoid excess work
       resultType = resolveMethodArgumentType(resultType);
     }
@@ -193,10 +191,12 @@ public void enterBlockStatements(DroppingJavaParser.BlockStatementsContext ctx)
     DroppingJavaVisitor<String> visitor = new BodyComposingVisitor();
 
     String bodyText = visitor.visit(ctx);
+    if (bodyText == null)       // there is no profit in dealing with absent body text anymore
+      return;
     bodyText = makeTypeNamesFullyQualified(bodyText);
     TargetMethod currentMethod = targetsMap.get(composeCurrentKey()).getLast();
     bodyText = obfuscateParameterReferences(bodyText, currentMethod.getFormalParams());
-    currentMethod.setText(bodyText);
+    currentMethod.setText("{ " + bodyText + " }");
   }
   //endregion
 
@@ -204,7 +204,7 @@ public void enterBlockStatements(DroppingJavaParser.BlockStatementsContext ctx)
   /**
    * Extracts formal parameters types and names and stores them into the given target method.
    * @param method target method to store extracted parameters into
-   * @param anyParams  parse rule context of formal parameters list; may be {@code null}
+   * @param anyParams parse rule context of formal parameters list; may be {@code null}
    */
   private void storeMethodParams(TargetMethod method, DroppingJavaParser.FormalParameterListContext anyParams) {
     if (anyParams == null) return;
@@ -214,9 +214,12 @@ private void storeMethodParams(TargetMethod method, DroppingJavaParser.FormalPar
     DroppingJavaParser.FormalParametersContext formalParams = anyParams.formalParameters();
     if (formalParams != null) {
       for (DroppingJavaParser.FormalParameterContext param : formalParams.formalParameter()) {
-        paramType = getPureTypeName(param.unannType());
+        paramType = extractPureTypeName(param.unannType());
         paramType = resolveMethodArgumentType(paramType);
         paramName = param.variableDeclaratorId().Identifier().getText();
+        if (param.variableDeclaratorId().dims() != null) {          // dimensions might be specified on param name
+          paramType = paramType + param.variableDeclaratorId().dims().getText();
+        }
         method.getFormalParams().add(new Argument(paramType, paramName));
       }
     }
@@ -225,11 +228,17 @@ private void storeMethodParams(TargetMethod method, DroppingJavaParser.FormalPar
     if (lastFormalParam != null) {
       DroppingJavaParser.FormalParameterContext formalParam = lastFormalParam.formalParameter();
       if (formalParam != null) {
-        paramType = getPureTypeName(formalParam.unannType());
+        paramType = extractPureTypeName(formalParam.unannType());
         paramName = formalParam.variableDeclaratorId().Identifier().getText();
+        if (formalParam.variableDeclaratorId().dims() != null) {          // dimensions might be specified on param name
+          paramType = paramType + formalParam.variableDeclaratorId().dims().getText();
+        }
       } else {
-        paramType = getPureTypeName(lastFormalParam.unannType());
+        paramType = extractPureTypeName(lastFormalParam.unannType());
         paramName = lastFormalParam.variableDeclaratorId().Identifier().getText();
+        if (lastFormalParam.variableDeclaratorId().dims() != null) {      // dimensions might be specified on param name
+          paramType = paramType + lastFormalParam.variableDeclaratorId().dims().getText();
+        }
       }
       paramType = resolveMethodArgumentType(paramType);
       method.getFormalParams().add(new Argument(paramType, paramName));
@@ -265,7 +274,7 @@ private String resolveMethodArgumentType(String argumentType) {
    * @param typeCtx type rule context to extract the name from
    * @return simple name of the type (with package and type parameters cleaned off)
    */
-  private String getPureTypeName(RuleContext typeCtx) {
+  private String extractPureTypeName(RuleContext typeCtx) {
     DroppingJavaVisitor<String> visitor = new PureTypeNameComposingVisitor();
     return visitor.visit(typeCtx);
   }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/PureTypeNameComposingVisitor.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/PureTypeNameComposingVisitor.java
index 8393c3d..31464da 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/PureTypeNameComposingVisitor.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/PureTypeNameComposingVisitor.java
@@ -5,7 +5,8 @@
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
 
 /**
- * Simple visitor that assembles a string from all the terminal nodes except {@code dims, typeArguments, annotation}.
+ * Simple visitor that assembles a string from all the terminal nodes excluding {@code typeArguments, annotation}
+ * but including dimensions (i.e. {@code []}).
  */
 class PureTypeNameComposingVisitor extends DroppingJavaBaseVisitor<String> {
 
@@ -21,7 +22,7 @@ protected String aggregateResult(String aggregate, String nextResult) {
 
   @Override
   public String visitDims(DroppingJavaParser.DimsContext ctx) {
-    return "";
+    return ctx.getText();
   }
 
   @Override
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/DropletV2.java b/src/main/java/ru/ftc/upc/testing/dropper/model/DropletV2.java
deleted file mode 100644
index d5dda0b..0000000
--- a/src/main/java/ru/ftc/upc/testing/dropper/model/DropletV2.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package ru.ftc.upc.testing.dropper.model;
-
-/**
- * @author Toparvion
- */
-public class DropletV2 {
-
-  private final String path;
-  private final TargetsMap targetsMap;
-
-  public DropletV2(String path, TargetsMap targetsMap) {
-    this.path = path;
-    this.targetsMap = targetsMap;
-  }
-
-  public String getPath() {
-    return path;
-  }
-
-  public TargetsMap getTargetsMap() {
-    return targetsMap;
-  }
-}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
index 184ca82..79b2993 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
@@ -68,7 +68,7 @@ public String toString() {
             ", cutpoint=" + cutpoint +
             ", resultType=" + resultType +
             ", formalParams=" + listParamsToString(formalParams) +
-            (importsOnDemand.size()<2 ? "" : ",\n\t\timportsOnDemand="+listImportsToString(importsOnDemand)) +
+            (importsOnDemand.size()<1 ? "" : ",\n\t\timportsOnDemand="+listImportsToString(importsOnDemand)) +
             ", text=" + (text == null || text.isEmpty() ? "(empty)" : "\n\t\t"+text+"\n\t") +
             '}';
   }
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
index 75e2527..c2ca3c9 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
@@ -30,31 +30,31 @@ public void nestedClassesAreRecognizedFully() throws Exception {
     System.out.println(actual);
     String expected = "ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
-            "\t\treturn 1 ;\n" +
+            "\t\t{ return 1 ; }\n" +
             "\t}\n" +
             "\tTargetMethod{name='method4', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
-            "\t\treturn 4 ;\n" +
+            "\t\t{ return 4 ; }\n" +
             "\t}\n" +
             "\tTargetMethod{name='method7', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
-            "\t\treturn 7 ;\n" +
+            "\t\t{ return 7 ; }\n" +
             "\t}\n" +
             "}\n" +
             "ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses$InnerClass1 -> {\n" +
             "\tTargetMethod{name='method2', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
-            "\t\treturn 2 ;\n" +
+            "\t\t{ return 2 ; }\n" +
             "\t}\n" +
             "\tTargetMethod{name='method3', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
-            "\t\treturn 3 ;\n" +
+            "\t\t{ return 3 ; }\n" +
             "\t}\n" +
             "}\n" +
             "ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses$InnerClass2 -> {\n" +
             "\tTargetMethod{name='method5', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
-            "\t\treturn 5 ;\n" +
+            "\t\t{ return 5 ; }\n" +
             "\t}\n" +
             "}\n" +
             "ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses$InnerClass2$InnerClass3 -> {\n" +
             "\tTargetMethod{name='method6', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
-            "\t\treturn 6 ;\n" +
+            "\t\t{ return 6 ; }\n" +
             "\t}\n" +
             "}\n";
     assertEquals(expected, actual);
@@ -67,24 +67,42 @@ public void methodHeadersAreRecognizedFully() throws Exception {
     String actual = targetsMap.toString();
     System.out.println(actual);
     String expected = "ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders -> {\n" +
-            "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(), text=(empty)}\n" +
-            "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(java.util.Stack param1), text=(empty)}\n" +
-            "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(float arg), text=(empty)}\n" +
-            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
-            "\tTargetMethod{name='method2', cutpoint=INSTEAD, resultType=void, formalParams=(int a), text=(empty)}\n" +
-            "\tTargetMethod{name='method3', cutpoint=INSTEAD, resultType=void, formalParams=(java.util.Map map), text=(empty)}\n" +
-            "\tTargetMethod{name='method4', cutpoint=INSTEAD, resultType=void, formalParams=(java.util.List xs), text=(empty)}\n" +
-            "\tTargetMethod{name='method5', cutpoint=INSTEAD, resultType=void, formalParams=(java.util.UUID u1, java.util.Date d2), text=(empty)}\n" +
-            "\tTargetMethod{name='method6', cutpoint=INSTEAD, resultType=void, formalParams=(double d1, double d2), text=(empty)}\n" +
-            "\tTargetMethod{name='method7', cutpoint=INSTEAD, resultType=double, formalParams=(), text=\n" +
-            "\t\treturn Math . random ( ) ;\n" +
+            "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(),\n" +
+            "\t\timportsOnDemand=(java.util), text=(empty)}\n" +
+            "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(Stack param1),\n" +
+            "\t\timportsOnDemand=(java.util), text=(empty)}\n" +
+            "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(float arg),\n" +
+            "\t\timportsOnDemand=(java.util), text=(empty)}\n" +
+            "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(),\n" +
+            "\t\timportsOnDemand=(java.util), text=(empty)}\n" +
+            "\tTargetMethod{name='method2', cutpoint=INSTEAD, resultType=void, formalParams=(int a),\n" +
+            "\t\timportsOnDemand=(java.util), text=(empty)}\n" +
+            "\tTargetMethod{name='method3', cutpoint=INSTEAD, resultType=void, formalParams=(Map map),\n" +
+            "\t\timportsOnDemand=(java.util), text=(empty)}\n" +
+            "\tTargetMethod{name='method4', cutpoint=INSTEAD, resultType=void, formalParams=(List xs),\n" +
+            "\t\timportsOnDemand=(java.util), text=(empty)}\n" +
+            "\tTargetMethod{name='method5', cutpoint=INSTEAD, resultType=void, formalParams=(UUID u1, Date d2),\n" +
+            "\t\timportsOnDemand=(java.util), text=(empty)}\n" +
+            "\tTargetMethod{name='method6', cutpoint=INSTEAD, resultType=void, formalParams=(double d1, double d2),\n" +
+            "\t\timportsOnDemand=(java.util), text=(empty)}\n" +
+            "\tTargetMethod{name='method7', cutpoint=INSTEAD, resultType=double, formalParams=(),\n" +
+            "\t\timportsOnDemand=(java.util), text=\n" +
+            "\t\t{ return Math . random ( ) ; }\n" +
+            "\t}\n" +
+            "\tTargetMethod{name='method8', cutpoint=INSTEAD, resultType=Set, formalParams=(EventObject eo),\n" +
+            "\t\timportsOnDemand=(java.util), text=\n" +
+            "\t\t{ return Collections . emptySet ( ) ; }\n" +
             "\t}\n" +
-            "\tTargetMethod{name='method8', cutpoint=INSTEAD, resultType=java.util.Set, formalParams=(java.util.EventObject eo), text=\n" +
-            "\t\treturn java.util.Collections . emptySet ( ) ;\n" +
+            "\tTargetMethod{name='method9', cutpoint=INSTEAD, resultType=Double[], formalParams=(Double[] p1, Double[][] p2, Double[] p3, Double[][] p4),\n" +
+            "\t\timportsOnDemand=(java.util), text=\n" +
+            "\t\t{ return new Double [ 0 ] ; }\n" +
             "\t}\n" +
+            "\tTargetMethod{name='method10', cutpoint=INSTEAD, resultType=void, formalParams=(java.security.KeyStore$SecretKeyEntry entry),\n" +
+            "\t\timportsOnDemand=(java.util), text=(empty)}\n" +
             "}\n" +
             "ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders$InnerClass -> {\n" +
-            "\tTargetMethod{name='InnerClass', cutpoint=INSTEAD, resultType=null, formalParams=(java.util.Deque arg), text=(empty)}\n" +
+            "\tTargetMethod{name='InnerClass', cutpoint=INSTEAD, resultType=null, formalParams=(Deque arg),\n" +
+            "\t\timportsOnDemand=(java.util), text=(empty)}\n" +
             "}\n";
     assertEquals(expected, actual);
   }
@@ -97,11 +115,11 @@ public void methodBodiesAreRecognizedFully() throws Exception {
     System.out.println(actual);
     String expected = "ru/ftc/upc/testing/dropper/lang/samples/MethodBodies -> {\n" +
             "\tTargetMethod{name='MethodBodies', cutpoint=INSTEAD, resultType=null, formalParams=(String name), text=\n" +
-            "\t\tSystem . out . println ( \"Hello from constructor :) \" ) ;\n" +
+            "\t\t{ System . out . println ( \"Hello from constructor :) \" ) ; }\n" +
             "\t}\n" +
             "\tTargetMethod{name='MethodBodies', cutpoint=INSTEAD, resultType=null, formalParams=(), text=(empty)}\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=boolean, formalParams=(), text=\n" +
-            "\t\tif ( Math . random ( ) > 0.5d ) { return true ; } else { return false ; }\n" +
+            "\t\t{ if ( Math . random ( ) > 0.5d ) { return true ; } else { return false ; } }\n" +
             "\t}\n" +
             "}\n";
     assertEquals(expected, actual);
@@ -115,15 +133,15 @@ public void enumTypesAreRecognizedFully() throws Exception {
     System.out.println(actual);
     String expected = "ru/ftc/upc/testing/dropper/lang/samples/RootEnumeration -> {\n" +
             "\tTargetMethod{name='RootEnumeration', cutpoint=INSTEAD, resultType=null, formalParams=(), text=\n" +
-            "\t\tString nothing = \"I'm the most enumerated constructor ever!\" ;\n" +
+            "\t\t{ String nothing = \"I'm the most enumerated constructor ever!\" ; }\n" +
             "\t}\n" +
             "\tTargetMethod{name='getByName', cutpoint=INSTEAD, resultType=RootEnumeration, formalParams=(String name), text=\n" +
-            "\t\tfor ( RootEnumeration rootEnum : values ( ) ) { if ( rootEnum . toString ( ) . equals ( $1 ) ) { return rootEnum ; } } throw new IllegalArgumentException ( \"Not found: \" + $1 ) ;\n" +
+            "\t\t{ for ( RootEnumeration rootEnum : values ( ) ) { if ( rootEnum . toString ( ) . equals ( $1 ) ) { return rootEnum ; } } throw new IllegalArgumentException ( \"Not found: \" + $1 ) ; }\n" +
             "\t}\n" +
             "}\n" +
             "ru/ftc/upc/testing/dropper/lang/samples/RootEnumeration$InnerEnum -> {\n" +
             "\tTargetMethod{name='isTheSame', cutpoint=INSTEAD, resultType=boolean, formalParams=(Enum e), text=\n" +
-            "\t\treturn INNER_ENUM . toString ( ) . equals ( $1 . toString ( ) ) ;\n" +
+            "\t\t{ return INNER_ENUM . toString ( ) . equals ( $1 . toString ( ) ) ; }\n" +
             "\t}\n" +
             "}\n";
     assertEquals(expected, actual);
@@ -140,20 +158,20 @@ public void interfaceTypesAreRecognizedFully() throws Exception {
             "\tTargetMethod{name='method2', cutpoint=INSTEAD, resultType=boolean, formalParams=(int two), text=(empty)}\n" +
             "\tTargetMethod{name='method3', cutpoint=INSTEAD, resultType=RootInterface, formalParams=(java.util.Set longs), text=(empty)}\n" +
             "\tTargetMethod{name='method5', cutpoint=INSTEAD, resultType=double, formalParams=(Float param1), text=\n" +
-            "\t\treturn Math . random ( ) ;\n" +
+            "\t\t{ return Math . random ( ) ; }\n" +
             "\t}\n" +
             "\tTargetMethod{name='newObservable', cutpoint=INSTEAD, resultType=java.util.Observable, formalParams=(java.util.List lof), text=\n" +
-            "\t\treturn new java.util.Observable ( ) ;\n" +
+            "\t\t{ return new java.util.Observable ( ) ; }\n" +
             "\t}\n" +
             "}\n" +
             "ru/ftc/upc/testing/dropper/lang/RootInterface$InnerIface -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=java.io.InputStream, formalParams=(), text=\n" +
-            "\t\treturn new java.io.FileInputStream ( \"\" ) ;\n" +
+            "\t\t{ return new java.io.FileInputStream ( \"\" ) ; }\n" +
             "\t}\n" +
             "}\n" +
             "ru/ftc/upc/testing/dropper/lang/RootInterface$InnerIface$InnerInnerIface -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=java.io.OutputStream, formalParams=(), text=\n" +
-            "\t\treturn new java.io.FileOutputStream ( \"\" ) ;\n" +
+            "\t\t{ return new java.io.FileOutputStream ( \"\" ) ; }\n" +
             "\t}\n" +
             "}\n";
     assertEquals(expected, actual);
@@ -167,7 +185,7 @@ public void typesCombinationsAreRecognizedFully() throws Exception {
     System.out.println(actual);
     String expected = "ru/ftc/upc/testing/dropper/lang/samples/TypesCombination -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=\n" +
-            "\t\tSystem . console ( ) ;\n" +
+            "\t\t{ System . console ( ) ; }\n" +
             "\t}\n" +
             "}\n" +
             "ru/ftc/upc/testing/dropper/lang/samples/TypesCombination$InnerInterface -> {\n" +
@@ -181,13 +199,13 @@ public void typesCombinationsAreRecognizedFully() throws Exception {
             "}\n" +
             "ru/ftc/upc/testing/dropper/lang/samples/SiblingClass -> {\n" +
             "\tTargetMethod{name='method', cutpoint=INSTEAD, resultType=double, formalParams=(), text=\n" +
-            "\t\treturn Math . random ( ) ;\n" +
+            "\t\t{ return Math . random ( ) ; }\n" +
             "\t}\n" +
             "}\n" +
             "ru/ftc/upc/testing/dropper/lang/samples/SiblingEnum -> {\n" +
             "\tTargetMethod{name='SiblingEnum', cutpoint=INSTEAD, resultType=null, formalParams=(), text=(empty)}\n" +
             "\tTargetMethod{name='getMe', cutpoint=INSTEAD, resultType=SiblingEnum, formalParams=(), text=\n" +
-            "\t\treturn this ;\n" +
+            "\t\t{ return this ; }\n" +
             "\t}\n" +
             "}\n" +
             "ru/ftc/upc/testing/dropper/lang/samples/SiblingEnum$InnerInterface -> {\n" +
@@ -220,8 +238,8 @@ public void importMapIsComposedCorrectly() throws Exception {
     System.out.println(actualTargetsMap);
     String expectedTargetsMap = "ru/ftc/upc/testing/dropper/lang/samples/Imports -> {\n" +
             "\tTargetMethod{name='Imports', cutpoint=INSTEAD, resultType=null, formalParams=(),\n" +
-            "\t\timportsOnDemand=(ru.ftc.upc.testing.dropper.lang.samples, java.math), text=\n" +
-            "\t\tSystem . out . println ( ) ; BigInteger bigInteger = new BigInteger ( \"31415926525\" ) ; double java.lang.Math.random = java.lang.Math.random ( ) ; int maxInt = java.lang.Integer.MAX_VALUE ; System . out . printf ( \"%d, %d, %d\" , MAX_EXPONENT , MIN_EXPONENT , MIN_VALUE ) ;\n" +
+            "\t\timportsOnDemand=(java.math), text=\n" +
+            "\t\t{ System . out . println ( ) ; BigInteger bigInteger = new BigInteger ( \"31415926525\" ) ; double java.lang.Math.random = java.lang.Math.random ( ) ; int maxInt = java.lang.Integer.MAX_VALUE ; System . out . printf ( \"%d, %d, %d\" , MAX_EXPONENT , MIN_EXPONENT , MIN_VALUE ) ; }\n" +
             "\t}\n" +
             "}\n";
     assertEquals(expectedTargetsMap, actualTargetsMap);
@@ -253,7 +271,7 @@ public void typeNamesInMethodBodiesAreResolvedCorrectly() throws Exception {
     System.out.println(actual);
     String expected = "dp/DPClientImpl -> {\n" +
             "\tTargetMethod{name='currencyRate', cutpoint=INSTEAD, resultType=dp.models.QuickPay$AnsCurrencyRate, formalParams=(dp.models.QuickPay$ReqCurrencyRate reqCurrencyRate), text=\n" +
-            "\t\ttry { java.io.FileReader stubReader = new java.io.FileReader ( System . getProperty ( \"user.dir\" ) + java.io.File . separator + \"AnsCurrencyRate.xml\" ) ; javax.xml.bind.Unmarshaller unmarshaller = quickPayJbcDoc . createUnmarshaller ( ) ; dp.models.QuickPay quickPay = ( dp.models.QuickPay ) unmarshaller . unmarshal ( stubReader ) ; log . info ( \"Rates were loaded from file AnsCurrencyRate.xml.\" ) ; stubReader . close ( ) ; return quickPay . getInfoService ( ) . getAnsCurrencyRate ( ) ; } catch ( Exception e ) { log . error ( \"Unable to load rates from file. Falling back to real service.\" , e ) ; dp . models . QuickPay quickPay = dp.models.QuickPay . infoService ( ) ; quickPay . getInfoService ( ) . setReqCurrencyRate ( $1 ) ; quickPay = sendQuickPay ( quickPay , false , false ) ; dp.models.QuickPay . AnsCurrencyRate ans = quickPay . getInfoService ( ) . getAnsCurrencyRate ( ) ; return ans ; }\n" +
+            "\t\t{ try { java.io.FileReader stubReader = new java.io.FileReader ( System . getProperty ( \"user.dir\" ) + java.io.File . separator + \"AnsCurrencyRate.xml\" ) ; javax.xml.bind.Unmarshaller unmarshaller = quickPayJbcDoc . createUnmarshaller ( ) ; dp.models.QuickPay quickPay = ( dp.models.QuickPay ) unmarshaller . unmarshal ( stubReader ) ; log . info ( \"Rates were loaded from file AnsCurrencyRate.xml.\" ) ; stubReader . close ( ) ; return quickPay . getInfoService ( ) . getAnsCurrencyRate ( ) ; } catch ( Exception e ) { log . error ( \"Unable to load rates from file. Falling back to real service.\" , e ) ; dp . models . QuickPay quickPay = dp.models.QuickPay . infoService ( ) ; quickPay . getInfoService ( ) . setReqCurrencyRate ( $1 ) ; quickPay = sendQuickPay ( quickPay , false , false ) ; dp.models.QuickPay . AnsCurrencyRate ans = quickPay . getInfoService ( ) . getAnsCurrencyRate ( ) ; return ans ; } }\n" +
             "\t}\n" +
             "}\n";
     assertEquals(expected, actual);
@@ -268,7 +286,7 @@ public void methodArgumentTypesAreResolvedCorrectly() throws Exception {
 
     String expected = "ru/ftc/upc/testing/dropper/lang/samples/NestedTypesAmongMethodArguments -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=java.util.Map$Entry, formalParams=(java.security.KeyStore$SecretKeyEntry arg), text=\n" +
-            "\t\treturn new java.util.AbstractMap . SimpleEntry < Long , String > ( 23L , \"\" ) ;\n" +
+            "\t\t{ return new java.util.AbstractMap . SimpleEntry < Long , String > ( 23L , \"\" ) ; }\n" +
             "\t}\n" +
             "}\n";
     assertEquals(expected, actual);
@@ -282,7 +300,7 @@ public void formalParamReferencesAreObfuscatedCorrectly() throws Exception {
     System.out.println(actual);
     String expected = "dp/DPClientImpl -> {\n" +
             "\tTargetMethod{name='fetchTransferStatus', cutpoint=INSTEAD, resultType=String, formalParams=(String oID, boolean needFlag), text=\n" +
-            "\t\tString statusStr = null ; try { java.util.Properties stub = new java.util.Properties ( ) ; stub . load ( new java.io.FileReader ( System . getProperty ( \"user.dir\" ) + java.io.File . separator + \"dp-edit-mock.properties\" ) ) ; statusStr = stub . getProperty ( $1 ) ; if ( statusStr != null ) { statusStr = statusStr . trim ( ) ; log . warn ( \"For STRoID={} transfer status '{}' was taken from mock.\" , $1 , statusStr ) ; } } catch ( java.io.IOException e ) { log . error ( \"Failed to load mocked transfer edit statuses.\" , e ) ; } if ( statusStr == null ) { dp.models.QuickPay quickPay = dp.models.QuickPay . infoService ( ) ; dp.models.ReqTransferSearch req = new dp.models.ReqTransferSearch ( ) ; req . setOID ( getReserve ( ) . oID ) ; quickPay . getInfoService ( ) . setReqTransferSearch ( req ) ; quickPay = sendQuickPay ( quickPay , false , $2 ) ; statusStr = quickPay . getInfoService ( ) . getAnsTransferSearch ( ) . getTransferStatus ( ) ; } return statusStr ;\n" +
+            "\t\t{ String statusStr = null ; try { java.util.Properties stub = new java.util.Properties ( ) ; stub . load ( new java.io.FileReader ( System . getProperty ( \"user.dir\" ) + java.io.File . separator + \"dp-edit-mock.properties\" ) ) ; statusStr = stub . getProperty ( $1 ) ; if ( statusStr != null ) { statusStr = statusStr . trim ( ) ; log . warn ( \"For STRoID={} transfer status '{}' was taken from mock.\" , $1 , statusStr ) ; } } catch ( java.io.IOException e ) { log . error ( \"Failed to load mocked transfer edit statuses.\" , e ) ; } if ( statusStr == null ) { dp.models.QuickPay quickPay = dp.models.QuickPay . infoService ( ) ; dp.models.ReqTransferSearch req = new dp.models.ReqTransferSearch ( ) ; req . setOID ( getReserve ( ) . oID ) ; quickPay . getInfoService ( ) . setReqTransferSearch ( req ) ; quickPay = sendQuickPay ( quickPay , false , $2 ) ; statusStr = quickPay . getInfoService ( ) . getAnsTransferSearch ( ) . getTransferStatus ( ) ; } return statusStr ; }\n" +
             "\t}\n" +
             "}\n";
     assertEquals(expected, actual);
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java
index 4291bf5..360c508 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java
@@ -1,19 +1,7 @@
 package ru.ftc.upc.testing.dropper.lang.samples;
 
-import java.io.BufferedInputStream;
-import java.io.FileNotFoundException;
-import java.io.InputStream;
-import java.util.Collections;
-import java.util.Currency;
-import java.util.Date;
-import java.util.Deque;
-import java.util.EventObject;
-import java.util.List;
-import java.util.Map;
-import java.util.Observer;
-import java.util.Set;
-import java.util.Stack;
-import java.util.UUID;
+import java.security.KeyStore;
+import java.util.*;
 
 @SuppressWarnings("unused")
 public class VariousMethodHeaders {
@@ -48,4 +36,12 @@ Set<Currency> method8(EventObject eo) {
     return Collections.emptySet();
   }
 
+  Double[] method9(Double[] p1, Double[][] p2, Double p3[], Double[] p4[]) {
+    return new Double[0];
+  }
+
+  void method10(KeyStore.SecretKeyEntry entry) {
+
+  }
+
 }
diff --git a/src/test/java/sampleapp/standalone/painter/DrawPane.java b/src/test/java/sampleapp/standalone/painter/DrawPane.java
new file mode 100644
index 0000000..63f3572
--- /dev/null
+++ b/src/test/java/sampleapp/standalone/painter/DrawPane.java
@@ -0,0 +1,151 @@
+/**
+ *
+ */
+package sampleapp.standalone.painter;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+
+public class DrawPane extends JComponent implements Runnable {
+
+  private int n;
+  private double t = 0.0;
+  private double dt = 0.0004;
+
+  private float red;
+  private float green;
+  private float blue;
+
+  private JProgressBar indicator;
+  private Painter parent;
+
+  int xs[] = new int[200];            // !!
+  int ys[] = new int[200];            // !!
+
+  // just a test
+  private double t2 = 0.0001;
+
+  public int dkmx = 64, dkmy = 64;
+  public int rmx = 25, rmy = 25;
+  public int rbx = 115, rby = 115;
+
+  private Thread anim;
+  private boolean doAnim = true;
+  private boolean runnable = true;
+  private MouseWheelListener ml;
+  private MouseListener mb;
+
+  public DrawPane(JProgressBar indicator, int points, Painter parent) {
+    this.indicator = indicator;
+    this.n = points;
+    this.parent = parent;
+
+    ml = new MouseAdapter() {                      // обработка вращения колесика мыши
+      public void mouseWheelMoved(MouseWheelEvent e) {
+        int change = e.getWheelRotation();
+        //System.out.println("Mouse wheel has been rounded for " + change);
+        dt -= (double) change / 50000;
+
+      }
+    };
+    this.addMouseWheelListener(ml);          // назначение слушателя
+
+    mb = new MouseAdapter() {                  // обработчик кнопок мыши
+      public void mousePressed(MouseEvent e) {
+        if (e.getButton() == MouseEvent.BUTTON2)  // колесо
+          dt = 0.0005;
+      }
+    };
+    this.addMouseListener(mb);                // назначение слушателя
+
+    anim = new Thread(this, "Shape Animation");
+    anim.start();
+  }
+
+  @Override
+  public void paintComponent(Graphics g) {
+    Graphics2D g2d = (Graphics2D) g;
+//        calculate();
+    g2d.setBackground(Color.WHITE);
+    g2d.clearRect(0, 0, this.getWidth(), this.getHeight());              // удаление предыдущей фигуры
+    red = ((float) Math.sin(t * dkmx) + 1) / 2;
+    green = (float) (Math.sin(t + n) + 1) / 2;
+    blue = (float) (Math.cos(t + n) + 1) / 2;
+    g2d.setColor(new Color(red, green, blue));              // назначение цвета
+    g2d.drawPolygon(xs, ys, n);                                  // построение фигуры
+
+  }
+
+  private void calculate() {
+    int i;
+    double r, x, y;
+    Dimension dm = getSize();
+    dkmx = dkmy = parent.getDkm();
+    rbx = rby = parent.getRb();
+    rmx = rmy = parent.getRm();
+    t2 += parent.getBDelta();
+    double round = 2 * Math.PI;
+    for (i = 0; i < n; i++) {
+      r = (double) i / (double) n * round + t; // +t
+      x = Math.cos(r + t2) * rbx + Math.sin(r * dkmx) * rmx + dm.width / 2;
+      y = Math.sin(r + t2) * rby + Math.cos(r * dkmy) * rmy + dm.height / 2;
+      xs[i] = (int) x;
+      ys[i] = (int) y;
+
+    }
+  }
+
+
+  /**
+   * @param n the n to set
+   */
+  public void setN(int n) {
+    this.n = n;
+  }
+
+  /**
+   * @return the n
+   */
+  public int getN() {
+    return n;
+  }
+
+  /**
+   * @param doAnim the doAnim to set
+   */
+  public void setDoAnim(boolean doAnim) {
+    this.doAnim = doAnim;
+  }
+
+  public void run() {
+    long times = 0;
+    while (runnable) {
+      t += doAnim ? dt : 0.0;
+//            t2 -= 0.0001;
+      long startTime = System.nanoTime();
+      calculate();
+      long stopTime = System.nanoTime();
+      repaint();
+      if (times % 80 == 0) {
+        int time = (int) (stopTime - startTime);
+        indicator.setValue(time);
+        indicator.setString(String.valueOf(time) + " нс");
+      }
+
+      times++;
+      try {
+        Thread.sleep(10);
+      } catch (InterruptedException e) {
+        // TODO Auto-generated catch block
+        e.printStackTrace();
+      }
+    }
+  }
+
+  public void dispose() {
+    this.removeMouseListener(mb);
+    this.removeMouseWheelListener(ml);
+    runnable = false;
+  }
+}
diff --git a/src/test/java/sampleapp/standalone/painter/DrawPaneDroplet.java b/src/test/java/sampleapp/standalone/painter/DrawPaneDroplet.java
new file mode 100644
index 0000000..46a4493
--- /dev/null
+++ b/src/test/java/sampleapp/standalone/painter/DrawPaneDroplet.java
@@ -0,0 +1,54 @@
+/**
+ *
+ */
+package sampleapp.standalone.painter;
+
+import javax.swing.*;
+import java.awt.*;
+import java.util.UUID;
+
+/**
+ * @author Toparvion
+ */
+public class DrawPaneDroplet extends JComponent /*implements Runnable*/ {
+
+  public int dkmx, dkmy;
+  private int n;
+  private double t;
+  int xs[];
+  int ys[];
+  private float red;
+  private float green;
+  private float blue;
+
+  /**
+   *
+   * @param indicator
+   * @param points
+   * @param parent
+   * @cutpoint BEFORE
+   */
+  public DrawPaneDroplet(JProgressBar indicator, int points, Painter parent) {
+    System.out.println("UUID: " + UUID.randomUUID().toString());
+    System.out.println("Parent component size is " + parent.getSize().toString());
+  }
+
+  /**
+   *
+   * @param g
+   * @cutpoint INSTEAD
+   */
+  @Override
+  public void paintComponent(Graphics g) {
+    Graphics2D g2d = (Graphics2D) g;
+//        calculate();
+    g2d.setBackground(Color.ORANGE);
+    g2d.clearRect(0, 0, this.getWidth(), this.getHeight());              // удаление предыдущей фигуры
+    red = ((float) Math.sin(t * dkmx) + 1) / 2;
+    green = (float) (Math.sin(t + n) + 1) / 2;
+    blue = (float) (Math.cos(t + n) + 1) / 2;
+    g2d.setColor(new Color(red, green, blue));              // назначение цвета
+    g2d.drawPolygon(xs, ys, n);                                  // построение фигуры
+  }
+
+}
diff --git a/src/test/java/sampleapp/standalone/painter/Painter.java b/src/test/java/sampleapp/standalone/painter/Painter.java
new file mode 100644
index 0000000..08c267d
--- /dev/null
+++ b/src/test/java/sampleapp/standalone/painter/Painter.java
@@ -0,0 +1,429 @@
+/**
+ * 		Главный модуль программы; отвечает за инициализацию (в любом режиме)
+ * 		и построение/заполнение области программы.
+ */
+package sampleapp.standalone.painter;
+
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+public class Painter extends JPanel {
+
+	private PainterApplet applet = null;
+	private JFrame frame = null;
+	private JTextField statusField;
+	private JTabbedPane tabbedPane;
+	private JPanel settingsPanel;
+	private JPanel topPane;
+//	private JPanel bottomPane;
+	private JMenuBar menuBar;
+
+    final private String[] names = {"Пинта", "Нинья", "Мария", "Санта", "Доминика"};
+    final private int points[] = {80, 98, 130, 137, 200};
+    final private int dkm_def = 64;
+    final private int rb_def = 115;
+    final private int rm_def = 25;
+
+    private double bDelta = 0.0;
+    private int dkm = dkm_def;
+    private int rb  = rb_def;
+    private int rm  = rm_def;
+
+	/**
+	 * @param applet объект апплета
+	 */
+	public Painter(PainterApplet applet) {
+		this.applet = applet;
+		if (applet == null) {
+			frame = new JFrame("Лабораторная работа №4");
+			frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		}
+		// set the layout
+        this.setPreferredSize(new Dimension(500, 420));
+        setLayout(new BorderLayout());
+
+		buildContent();
+
+		SwingUtilities.invokeLater(new Runnable() {
+			public void run() {
+				showFrame();
+			}
+		});
+	}
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		Painter painter = new Painter(null);
+
+	}
+	
+	public synchronized int getDkm() {
+        return dkm;
+    }
+
+    public synchronized int getRb() {
+        return rb;
+    }
+
+    public synchronized int getRm() {
+        return rm;
+    }
+
+    public synchronized double getBDelta() {
+        return bDelta;
+    }
+
+    public synchronized void setBDelta(double bDelta) {
+        this.bDelta = bDelta;
+    }
+
+    private void buildContent() {
+	
+		tabbedPane = new JTabbedPane();
+		tabbedPane.setTabPlacement(JTabbedPane.BOTTOM);
+        add(tabbedPane, BorderLayout.CENTER);
+
+		// создание и расположение Панели Настроек
+		settingsPanel = new JPanel();
+		settingsPanel.setLayout(new BorderLayout());
+		
+		topPane = new JPanel();
+		topPane.setLayout(new BorderLayout());
+		topPane.setBorder(BorderFactory.createTitledBorder("Свойства задания"));
+        JLabel welcome = new JLabel("<html>В этой программе параметры построения влияют на <i>все</i> оси и " +
+                "относятся ко <i>всем</i> активным фигурам.</html>");
+        topPane.add(welcome, BorderLayout.CENTER);
+        settingsPanel.add(topPane, BorderLayout.NORTH);
+
+        JPanel paramPane = createParamPane();
+        settingsPanel.add(paramPane, BorderLayout.WEST);
+        JPanel optionPane = createOptionPane();
+        settingsPanel.add(optionPane, BorderLayout.EAST);
+
+        JPanel bottomPane = this.createBottomPane();
+        settingsPanel.add(bottomPane, BorderLayout.SOUTH);
+
+        tabbedPane.addTab("Настройки", settingsPanel);
+
+        menuBar = createMenu();
+	    if (isApplet()) {
+	        applet.setJMenuBar(menuBar);
+	    } else {
+	        frame.setJMenuBar(menuBar);
+	    }			
+		
+		statusField = new JTextField("Добро пожаловать!");
+		statusField.setEditable(false);
+        tabbedPane.getModel().addChangeListener(new TabListener());// имеет непосредственное отношение к строке состояния
+        add(statusField, BorderLayout.SOUTH);
+
+    }
+
+    private JPanel createParamPane()
+    {
+        JPanel pane = new JPanel();
+        JSpinner spinner;
+        pane.setBorder(BorderFactory.createTitledBorder("Параметры построения"));
+		pane.setLayout(new GridBagLayout());
+		GridBagConstraints gbc = new GridBagConstraints();
+		gbc.ipadx = 10;
+		gbc.ipady = 4;
+		gbc.insets = new Insets(5,5,5,5);
+		gbc.anchor = GridBagConstraints.WEST;
+		gbc.fill = GridBagConstraints.HORIZONTAL;
+		pane.add(new JLabel("Коэффициент завихрения:"), gbc);
+        spinner = new JSpinner(new SpinnerNumberModel(dkm_def, 0, 128, 1));
+        spinner.addChangeListener(new ParamListener("dkm"));
+        pane.add(spinner, gbc);
+		gbc.gridy = 1;
+        // переход к следующей "строке" таблицы размещения
+		pane.add(new JLabel("Радиус завихрения:"), gbc);
+        spinner = new JSpinner(new SpinnerNumberModel(rm_def, 0 , 120, 1));
+        spinner.addChangeListener(new ParamListener("rm"));
+		pane.add(spinner, gbc);
+		gbc.gridy = 2;
+		pane.add(new JLabel("Основной радиус:"), gbc);
+        spinner = new JSpinner(new SpinnerNumberModel(rb_def, 0, 260, 1));
+        spinner.addChangeListener(new ParamListener("rb"));
+		pane.add(spinner, gbc);
+
+        return pane;
+    }
+
+    private JPanel createOptionPane()
+    {
+        JPanel pane = new JPanel();
+        pane.setLayout(new GridBagLayout());
+        GridBagConstraints gbc = new GridBagConstraints();
+        gbc.anchor = GridBagConstraints.WEST;
+        gbc.ipady = 10;
+        gbc.gridwidth = GridBagConstraints.REMAINDER;
+
+        JRadioButton option;
+        pane.setBorder(BorderFactory.createTitledBorder("Вращение основы"));
+
+        ButtonGroup optionGroup = new ButtonGroup();
+        option = new JRadioButton("Отсутствует", true);
+        option.addActionListener(new OptionListener(0));
+        optionGroup.add(option);
+        pane.add(option, gbc);
+
+        option = new JRadioButton("По часовой стрелке", false);
+        option.addActionListener(new OptionListener(5));
+        optionGroup.add(option);
+        pane.add(option, gbc);
+
+        option = new JRadioButton("Против часовой стрелки       ", false);
+        option.addActionListener(new OptionListener(-5));
+        optionGroup.add(option);
+        pane.add(option, gbc);
+
+        return pane;
+
+    }
+
+    private JPanel createBottomPane()
+    {
+        JPanel thePane = new JPanel();
+        thePane.setBorder(BorderFactory.createTitledBorder("Управление фигурами"));
+        GridBagLayout gbl = new GridBagLayout();
+        thePane.setLayout(gbl);
+        GridBagConstraints gbc = new GridBagConstraints();
+        
+        gbc.weightx = 1;
+        gbc.weighty = 0;
+        gbc.anchor = GridBagConstraints.WEST;
+        // заголовок "таблицы"
+        JLabel next = new JLabel("     Состояние");
+        thePane.add(next, gbc);
+        next = new JLabel("Сложность");
+        thePane.add(next, gbc);
+        next = new JLabel("Время расчета");
+        gbc.gridwidth = GridBagConstraints.REMAINDER;
+        thePane.add(next,gbc);
+        // тело "таблицы"
+        int i;
+        JCheckBox turner;
+        JLabel pointCnt;
+        JProgressBar prgs;
+        for(i=0; i<names.length; i++)
+        {
+            turner = new JCheckBox(names[i] + " активна");
+            gbc.gridy = i+1;
+            gbc.gridwidth = 1;
+            gbc.fill = GridBagConstraints.NONE;
+            thePane.add(turner, gbc);
+            pointCnt = new JLabel("[поток не запущен]");
+            pointCnt.setEnabled(false);
+            thePane.add(pointCnt, gbc);
+            prgs = new JProgressBar(90000, 270000);
+            prgs.setStringPainted(true);
+            prgs.setVisible(false);
+            gbc.gridwidth = GridBagConstraints.REMAINDER;
+            gbc.fill = GridBagConstraints.BOTH;
+            thePane.add(prgs, gbc);
+            turner.addActionListener(new ActivateListener(pointCnt, prgs, names[i], points[i]));
+
+        }
+
+        return thePane;
+
+    }
+
+    private JPanel createTab(JProgressBar prgs, final JLabel pointCnt, int points)
+    {
+        JPanel showTab = new JPanel();
+		showTab.setLayout(new BorderLayout());
+
+	    final DrawPane drawPane = new DrawPane(prgs, points, this);
+		drawPane.setPreferredSize(new Dimension(300, 300));
+		showTab.add(drawPane, BorderLayout.CENTER);
+
+		JPanel bottomPane = new JPanel();
+		bottomPane.setLayout(new BorderLayout());
+		bottomPane.setBorder(BorderFactory.createTitledBorder("Количество точек построения"));
+
+        JSlider nSlide = new JSlider(80, 200, points);
+		nSlide.setPaintTicks(true);
+		nSlide.setMajorTickSpacing(10);
+		nSlide.setMinorTickSpacing(1);
+		nSlide.setPaintLabels( true );
+		nSlide.setSnapToTicks( true );
+		nSlide.addChangeListener(new ChangeListener() {
+            public void stateChanged(ChangeEvent e) {
+    	        JSlider s1 = (JSlider)e.getSource();
+                int newValue = s1.getValue();
+                drawPane.setN(newValue);
+                pointCnt.setText(String.valueOf(newValue) + " точек");
+
+            }
+        });
+        bottomPane.add(nSlide, BorderLayout.CENTER);
+        showTab.add(bottomPane, BorderLayout.SOUTH);
+//		animCheck = new JCheckBox("Анимация");
+//		animCheck.addChangeListener(new ChangeListener() {
+//			public void stateChanged(ChangeEvent e)
+//			{
+//				JCheckBox doAnim = (JCheckBox)e.getSource();
+//				drawPane.setDoAnim(doAnim.isSelected());
+//			}
+//		});
+//		showTab.add(animCheck, BorderLayout.SOUTH);
+
+        showTab.putClientProperty("drawPane", drawPane);
+
+        return showTab;
+
+    }
+
+    private JMenuBar createMenu()
+	{
+		JMenuBar bar = new JMenuBar();		
+		JMenu menuX = new JMenu("Главное");
+
+        JMenuItem quit = new JMenuItem("Выход");
+        quit.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent event)
+            {
+                System.exit(0);
+            }
+        });
+        if (isApplet())
+            quit.setEnabled(false);
+        menuX.add(quit);
+
+        bar.add(menuX);
+
+		return bar;
+	}
+
+	public void showFrame() {
+		if (!isApplet() && frame != null) {
+			// put swingset in a frame and show it 
+			frame.getContentPane().add(this, BorderLayout.CENTER);
+			frame.setLocation(100, 100);
+            frame.pack();
+			frame.setVisible(true);
+		}
+	}
+
+	public boolean isApplet() {
+		return (applet != null);
+	}
+
+    class SliderListener implements ChangeListener {
+    	DrawPane dp;
+    	public SliderListener(DrawPane pane) {
+    	    dp = pane;
+    	}
+    	public void stateChanged(ChangeEvent e) {
+    	    JSlider s1 = (JSlider)e.getSource();
+    	    dp.setN(s1.getValue());
+    	}
+    }
+    
+
+    class TabListener implements ChangeListener {
+        public void stateChanged(ChangeEvent e) {
+            SingleSelectionModel model = (SingleSelectionModel) e.getSource();
+            int tabSelected = model.getSelectedIndex();
+            if (tabSelected == 0)
+                statusField.setText("Настройте параметры фигуры и перейдите на вкладку Просмотр");
+            if (tabSelected > 0)
+                statusField.setText("Используйте колесо мыши и кнопку под ним для управления анимацией");
+
+        }
+    }
+
+    class ActivateListener implements ActionListener {
+        private JLabel pointCnt;
+        private JProgressBar prgs;
+        private String name;
+        private int points;
+
+        private JPanel child = null;
+
+        public ActivateListener(JLabel pointCnt, JProgressBar prgs, String name, int points)
+        {
+            this.pointCnt = pointCnt;
+            this.prgs = prgs;
+            this.name = name;
+            this.points = points;
+        }
+        public void actionPerformed(ActionEvent event) {
+            JCheckBox src = (JCheckBox)event.getSource();
+            boolean set = src.isSelected();
+            if (set)                    // флажок установлен
+            {
+                if (child==null)
+                    child = createTab(prgs, pointCnt, points);
+                tabbedPane.addTab(name, child);
+
+            }
+            else                        // флажок снят
+            {
+                if (child!=null)
+                {
+                    tabbedPane.remove(child);
+                    DrawPane drawPane = (DrawPane)child.getClientProperty("drawPane");
+                    drawPane.dispose();
+                    child = null;
+                }
+
+            }
+            prgs.setVisible(set);
+            pointCnt.setEnabled(set);
+            pointCnt.setText(set ? (points+" точек"):"[поток не запущен]");
+
+        }
+
+    }
+
+    class OptionListener implements ActionListener
+    {
+        int delta;
+
+        public OptionListener(int delta)
+        {
+            this.delta = delta;
+        }
+
+        public void actionPerformed(ActionEvent event)
+        {
+            setBDelta((double)delta/1000.0);
+        }
+
+    }
+
+    class ParamListener implements ChangeListener
+    {
+        private String param;
+
+        public ParamListener(String param)
+        {
+            this.param = param;
+        }
+
+        public void stateChanged(ChangeEvent event)
+        {
+			JSpinner src = (JSpinner) event.getSource();
+			SpinnerNumberModel snm = (SpinnerNumberModel) src.getModel();
+			int newValue = snm.getNumber().intValue();
+            if (param == "dkm")
+                dkm = newValue;
+            if (param == "rb")
+                rb = newValue;
+            if (param == "rm")
+                rm = newValue;
+
+
+        }
+    }
+
+}
diff --git a/src/test/java/sampleapp/standalone/painter/PainterApplet.java b/src/test/java/sampleapp/standalone/painter/PainterApplet.java
new file mode 100644
index 0000000..88e0e5e
--- /dev/null
+++ b/src/test/java/sampleapp/standalone/painter/PainterApplet.java
@@ -0,0 +1,15 @@
+/**
+ * 
+ */
+package sampleapp.standalone.painter;
+
+import javax.swing.*;
+import java.awt.*;
+
+public class PainterApplet extends JApplet {
+	public void init()
+	{
+		getContentPane().setLayout(new BorderLayout());
+		getContentPane().add(new Painter(this), BorderLayout.CENTER);
+	}
+}
diff --git a/src/test/java/sampleapp/standalone/painter/PainterDroplet.java b/src/test/java/sampleapp/standalone/painter/PainterDroplet.java
new file mode 100644
index 0000000..65a7c2b
--- /dev/null
+++ b/src/test/java/sampleapp/standalone/painter/PainterDroplet.java
@@ -0,0 +1,94 @@
+/**
+ * 		Главный модуль программы; отвечает за инициализацию (в любом режиме)
+ * 		и построение/заполнение области программы.
+ */
+package sampleapp.standalone.painter;
+
+import javax.swing.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+public class PainterDroplet extends JPanel {
+
+	private JTextField statusField;
+	private JTabbedPane tabbedPane;
+    final private String[] names = {"Пинта", "Нинья", "Мария", "Санта", "Доминика"};
+    final private int points[] = {80, 98, 130, 137, 200};
+
+
+	/**
+	 * @param args
+   * @cutpoint BEFORE
+	 */
+	public static void main(String[] args) {
+    System.out.println("Length of arguments list: " + args.length);
+  }
+	
+  /**
+   * @cutpoint AFTER
+   */
+  private void buildContent() {
+      statusField.setText(statusField.getText() + " [Droplet is active ;) ]");
+  }
+
+
+ /*   private JPanel createBottomPane()
+    {
+        JPanel thePane = new JPanel();
+        thePane.setBorder(BorderFactory.createTitledBorder("Управление фигурами"));
+        GridBagLayout gbl = new GridBagLayout();
+        thePane.setLayout(gbl);
+        GridBagConstraints gbc = new GridBagConstraints();
+        
+        gbc.weightx = 1;
+        gbc.weighty = 0;
+        gbc.anchor = GridBagConstraints.WEST;
+        // заголовок "таблицы"
+        JLabel next = new JLabel("     Состояние");
+        thePane.add(next, gbc);
+        next = new JLabel("Сложность");
+        thePane.add(next, gbc);
+        next = new JLabel("Время расчета");
+        gbc.gridwidth = GridBagConstraints.REMAINDER;
+        thePane.add(next,gbc);
+        // тело "таблицы"
+        int i;
+        JCheckBox turner;
+        JLabel pointCnt;
+        JProgressBar prgs;
+        for(i=0; i<names.length; i++)
+        {
+            turner = new JCheckBox(names[i] + " активна");
+            gbc.gridy = i+1;
+            gbc.gridwidth = 1;
+            gbc.fill = GridBagConstraints.NONE;
+            thePane.add(turner, gbc);
+            pointCnt = new JLabel("[поток не запущен]");
+            pointCnt.setEnabled(false);
+            thePane.add(pointCnt, gbc);
+            prgs = new JProgressBar(90000, 270000);
+            prgs.setStringPainted(true);
+            prgs.setVisible(false);
+            gbc.gridwidth = GridBagConstraints.REMAINDER;
+            gbc.fill = GridBagConstraints.BOTH;
+            thePane.add(prgs, gbc);
+            turner.addActionListener(new ActivateListener(pointCnt, prgs, names[i], points[i]));
+
+        }
+
+        return thePane;
+
+    }
+
+*/
+ class ActivateListener implements ActionListener {
+
+   /**
+    * @cutpoint BEFORE
+    */
+   public void actionPerformed(ActionEvent event) {
+     System.out.println("Event happened on " + event.getWhen() + " ms.");
+   }
+
+ }
+}
diff --git a/src/test/java/sampleapp/standalone/painter/package-info.java b/src/test/java/sampleapp/standalone/painter/package-info.java
new file mode 100644
index 0000000..f253efc
--- /dev/null
+++ b/src/test/java/sampleapp/standalone/painter/package-info.java
@@ -0,0 +1,7 @@
+/**
+ * This package contains a sample standalone Swing application developed as a study work during taking Java
+ * programming course in the university.
+ *
+ * @author Toparvion
+ */
+package sampleapp.standalone.painter;
\ No newline at end of file
diff --git a/src/test/resources/DrawPaneDroplet.java b/src/test/resources/DrawPaneDroplet.java
deleted file mode 100644
index c056f5d..0000000
--- a/src/test/resources/DrawPaneDroplet.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- *
- */
-package lab3;
-
-import javax.swing.*;
-import java.util.*;
-
-/**
- * @author Toparvion
- */
-public class DrawPaneDroplet extends JComponent implements Runnable {
-
-  /**
-   *
-   * @param indicator
-   * @param points
-   * @param parent
-   * @cutpoint BEFORE
-   */
-  public DrawPaneDroplet(JProgressBar indicator, int points, Painter parent) {
-    System.out.println("UUID: " + UUID.randomUUID().toString());
-    System.out.println("Parent component size is " + parent.getSize().toString());
-  }
-
-  /**
-   * @cutpoint IGNORE
-   */
-  public void run() {
-    long times = 0;
-    times++;
-    try {
-      Thread.sleep(10);
-    } catch (InterruptedException e) {
-      e.printStackTrace();
-    }
-  }
-
-}
diff --git a/src/test/resources/JFrameDroplet.java b/src/test/resources/JFrameDroplet.java
new file mode 100644
index 0000000..906a620
--- /dev/null
+++ b/src/test/resources/JFrameDroplet.java
@@ -0,0 +1,14 @@
+package javax.swing;
+
+class JFrameDroplet {
+
+  /**
+   * @cutpoint BEFORE
+   * @param title
+   */
+  public JFrameDroplet(String title) {
+    if (title.contains("работа")) {
+      title = title + " (Droplet mode)";
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/test/resources/RequestInfoExampleDroplet.java b/src/test/resources/RequestInfoExampleDroplet.java
new file mode 100644
index 0000000..1398502
--- /dev/null
+++ b/src/test/resources/RequestInfoExampleDroplet.java
@@ -0,0 +1,55 @@
+/*
+* 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.
+*/
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ResourceBundle;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import util.HTMLFilter;
+
+/**
+ * Example servlet showing request information.
+ *
+ * @author James Duncan Davidson <duncan@eng.sun.com>
+ */
+
+public class RequestInfoExampleDroplet extends HttpServlet {
+
+  /**
+   *
+   * @param request
+   * @param response
+   * @throws IOException
+   * @throws ServletException
+   * @cutpoint AFTER
+   */
+  @Override
+  public void doGet(HttpServletRequest request,
+                    HttpServletResponse response)
+          throws IOException, ServletException
+  {
+    PrintWriter out = response.getWriter();
+    out.println("<h1>Droplets shine bright!</h1>");
+  }
+
+}
+
diff --git a/src/test/resources/Room.java b/src/test/resources/Room.java
new file mode 100644
index 0000000..276409f
--- /dev/null
+++ b/src/test/resources/Room.java
@@ -0,0 +1,77 @@
+package websocket.drawboard;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.concurrent.locks.ReentrantLock;
+
+import javax.imageio.ImageIO;
+
+import websocket.drawboard.wsmessages.BinaryWebsocketMessage;
+import websocket.drawboard.wsmessages.StringWebsocketMessage;
+
+/**
+ * A Room represents a drawboard where a number of
+ * users participate.<br><br>
+ *
+ * Note: Instance methods should only be invoked by calling
+ * {@link #invokeAndWait(Runnable)} to ensure access is correctly synchronized.
+ */
+public final class Room {
+
+    /**
+     * The current image of the room drawboard. DrawMessages that are
+     * received from Players will be drawn onto this image.
+     */
+    private final BufferedImage roomImage =
+            new BufferedImage(900, 600, BufferedImage.TYPE_INT_RGB);
+    private final Graphics2D roomGraphics = roomImage.createGraphics();
+
+  /**
+   * @cutpoint AFTER
+   */
+  public Room() {
+        roomGraphics.setBackground(Color.ORANGE);
+        roomGraphics.clearRect(0, 0, roomImage.getWidth(),
+                roomImage.getHeight());
+    }
+
+    /**
+     * A Player participates in a Room. It is the interface between the
+     * {@link Room} and the {@link Client}.<br><br>
+     *
+     * Note: This means a player object is actually a join between Room and
+     * Client.
+     */
+    public final class Player {
+
+        /**
+         * The room to which this player belongs.
+         */
+        private Room room;
+
+        private final Client client;
+
+        /**
+         * Handles the given DrawMessage by drawing it onto this Room's
+         * image and by broadcasting it to the connected players.
+         * @param msg
+         * @param msgId
+         * @cutpoint BEFORE
+         */
+        public void handleDrawMessage(DrawMessage msg, long msgId) {
+            System.out.println("Draw message is handled with type " + msg.getType() +
+                " and message id=" + msgId);
+        }
+
+
+    }
+}

From aae551bad880d129e14f7baf8c32f4b8bcb092f7 Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Thu, 7 Jul 2016 00:40:10 +0600
Subject: [PATCH 18/22] Migrated to SLF4J logging facade

---
 build.gradle                                  |  5 ++-
 .../upc/testing/dropper/DropletChecker.java   |  2 +-
 .../upc/testing/dropper/DropletLoader.java    | 12 +++---
 .../ftc/upc/testing/dropper/DropperAgent.java | 11 ++++--
 .../testing/dropper/PatchingTransformer.java  | 15 +++++---
 .../dropper/lang/DropletAssembler.java        | 10 +++--
 .../testing/dropper/DropletLoaderTest.java    |  5 ++-
 .../dropper/lang/CutpointAssemblerTest.java   | 17 +++++----
 .../dropper/lang/DropletAssemblerTest.java    | 38 ++++++++++---------
 9 files changed, 68 insertions(+), 47 deletions(-)

diff --git a/build.gradle b/build.gradle
index 3e81996..d4ef1ed 100644
--- a/build.gradle
+++ b/build.gradle
@@ -20,6 +20,8 @@ dependencies {
     compile 'org.slf4j:slf4j-api:1.7.7'
     compile group: 'org.antlr', name: 'antlr4-runtime', version: '4.5.3'
     testCompile group: 'junit', name: 'junit', version: '4.11'
+    testRuntime group: 'org.slf4j', name: 'slf4j-simple', version: '1.7.7'
+
 }
 
 jar {
@@ -37,7 +39,8 @@ jar {
 }
 
 task runPainterWithDebug(type: JavaExec, dependsOn: jar) {
-    classpath = sourceSets.test.runtimeClasspath
+    classpath = sourceSets.test.runtimeClasspath /*+
+            project.files('src/test/java/sampleapp/standalone/painter/slf4j-simple-1.7.7.jar')*/
     main 'sampleapp.standalone.painter.Painter'
     jvmArgs = ['-Dfile.encoding=UTF8',
                '-javaagent:build/libs/dropper-1.0.jar=' +
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/DropletChecker.java b/src/main/java/ru/ftc/upc/testing/dropper/DropletChecker.java
index 6bebc31..88b214f 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/DropletChecker.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/DropletChecker.java
@@ -16,7 +16,7 @@ public static void main(String[] args) {
     TargetsMap targetsMap = DropletLoader.loadDroplets(args[0]);
     System.out.printf("Loaded targets map:\n%s", targetsMap.toString());
 
-    System.out.println("\nDroplet(s) format is OK.");
+    System.out.println("\nListed droplet(s) format is OK.");
   }
 
   private static final String USAGE_HELP = "Usage: java -jar dropper.jar <droplet-list>\n" +
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/DropletLoader.java b/src/main/java/ru/ftc/upc/testing/dropper/DropletLoader.java
index 34d8a83..b85a72b 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/DropletLoader.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/DropletLoader.java
@@ -6,6 +6,8 @@
 import org.antlr.v4.runtime.RecognitionException;
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.ParseTreeWalker;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import ru.ftc.upc.testing.dropper.lang.DropletAssembler;
 import ru.ftc.upc.testing.dropper.lang.DropletFormatException;
 import ru.ftc.upc.testing.dropper.lang.UnderlineErrorListener;
@@ -19,6 +21,7 @@
  * @author Toparvion
  */
 abstract class DropletLoader {
+  private static final Logger log = LoggerFactory.getLogger(DropletLoader.class);
 
   static TargetsMap loadDroplets(String args) {
     String[] argTokens = args.split("[;,]");
@@ -29,15 +32,14 @@ static TargetsMap loadDroplets(String args) {
         overallMap.putAll(loadSingleDroplet(argToken));
 
       } catch (IOException e) {
-        System.err.printf("Failed to load droplet '%s'. Skipped.", argToken);
-        e.printStackTrace();
+        log.error(String.format("Failed to load droplet '%s'. Skipped.", argToken), e);
 
       } catch (DropletFormatException e) {
-        System.err.printf("Error during parsing droplet '%s'. Droplet is skipped.\n%s\n", argToken, e.getMessage());
+        log.error(String.format("Error during parsing droplet '%s'. Droplet is skipped.\n%s",
+                argToken, e.getMessage()), e);
 
       } catch (Exception e) {
-        System.err.printf("Failed to load droplet '%s'. Skipped.", argToken);
-        e.printStackTrace();
+        log.error(String.format("Failed to load droplet '%s'. Skipped.", argToken), e);
       }
     }
     return overallMap;
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java b/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java
index 4ec1a35..5445cce 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java
@@ -1,5 +1,7 @@
 package ru.ftc.upc.testing.dropper;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import ru.ftc.upc.testing.dropper.model.TargetsMap;
 
 import java.lang.instrument.Instrumentation;
@@ -9,20 +11,21 @@
  */
 @SuppressWarnings({"unused", "WeakerAccess"}) // the class is used by Java Instrumentation API and thus must be public
 public class DropperAgent {
+  private static final Logger log = LoggerFactory.getLogger(DropperAgent.class);
 
   public static void premain(String agentArgs, Instrumentation inst) {
     System.out.println(DROPPER_LOGO);
 
     Package pack = DropperAgent.class.getPackage();
-    System.out.printf("%s started (version: %s).\n", pack.getImplementationTitle(), pack.getImplementationVersion());
+    log.info("{} started (version: {}).", pack.getImplementationTitle(), pack.getImplementationVersion());
 
     long startTime = System.currentTimeMillis();
     TargetsMap targetsMap = DropletLoader.loadDroplets(agentArgs);
-    System.out.printf("Loaded targets map:\n%s\n", targetsMap.toString());
-    System.out.printf("Droplets loading took: %s ms\n", (System.currentTimeMillis()-startTime));
+    log.info("Loaded targets map:\n{}", targetsMap.toString());
+    log.info("Droplets loading took: {} ms", (System.currentTimeMillis()-startTime));
 
     if (targetsMap.isEmpty()) {
-      System.out.printf("No droplets to apply left after arguments processing. No byte code will be modified.\n");
+      log.warn("No droplets to apply left after arguments processing. No byte code will be modified.");
     } else {
       inst.addTransformer(new PatchingTransformer(targetsMap));
     }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java b/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java
index 8e638e2..e7a1aa4 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java
@@ -1,6 +1,8 @@
 package ru.ftc.upc.testing.dropper;
 
 import javassist.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import ru.ftc.upc.testing.dropper.model.Argument;
 import ru.ftc.upc.testing.dropper.model.TargetMethod;
 import ru.ftc.upc.testing.dropper.model.TargetsMap;
@@ -18,6 +20,8 @@
  * Created by Toparvion on 29.04.2016 12:50
  */
 class PatchingTransformer implements ClassFileTransformer {
+  private static final Logger log = LoggerFactory.getLogger(PatchingTransformer.class);
+
   /**
    * The package that is implicitly imported into every Javassist ClassPool instance and therefore should be considered
    * known while resolving formal parameters' FQ names.
@@ -70,7 +74,7 @@ public byte[] transform(ClassLoader loader,
       for (TargetMethod targetMethod : targetMethods) {
         try {
           if (IGNORE.equals(targetMethod.getCutpoint())) {
-            System.out.printf("Method '%s#%s' is skipped due to IGNORE cutpoint.\n", dottedClassName, targetMethod.getName());
+            log.info("Method '{}#{}' is skipped due to IGNORE cutpoint.", dottedClassName, targetMethod.getName());
             continue;
           }
           // in order to precisely select method to modify we need CtClass representation of all its formal parameters
@@ -95,18 +99,17 @@ public byte[] transform(ClassLoader loader,
           Cutpoint cutpoint = targetMethod.getCutpoint();
           MethodModifier modifier = cutpoint.modifierClass.newInstance();
           modifier.apply(ctMethod, targetMethod.getText());
-          System.out.printf("Method '%s' has been modified at %s cutpoint.\n", ctMethod.getLongName(), cutpoint);
+          log.info("Method '{}' has been modified at {} cutpoint.", ctMethod.getLongName(), cutpoint);
 
         } catch (Exception e) {
-          System.out.printf("Failed to modify target method '%s#%s'. Skipped.\n", dottedClassName, targetMethod.getName());
-          e.printStackTrace();
+          log.error(format("Failed to modify target method '%s#%s'. Skipped.",
+                  dottedClassName, targetMethod.getName()), e);
         }
       }
       return ctClass.toBytecode();
 
     } catch (Exception e) {
-      System.out.println(format("Failed to modify class '%s'. Skipped.", className));
-      e.printStackTrace();
+      log.error(format("Failed to modify class '%s'. Skipped.", className), e);
       return null;
     }
   }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
index 31b6465..04199c3 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
+++ b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
@@ -4,6 +4,8 @@
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.ParseTreeWalker;
 import org.antlr.v4.runtime.tree.TerminalNode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import ru.ftc.upc.testing.dropper.Cutpoint;
 import ru.ftc.upc.testing.dropper.lang.gen.*;
 import ru.ftc.upc.testing.dropper.model.Argument;
@@ -23,6 +25,7 @@
  * @author Toparvion
  */
 public class DropletAssembler extends DroppingJavaBaseListener {
+  static final Logger log = LoggerFactory.getLogger(DropletAssembler.class);
 
   /**
    * Mapping between all target classes and lists of their methods. These methods are targets for byte
@@ -102,9 +105,8 @@ public void enterStaticImportOnDemandDeclaration(DroppingJavaParser.StaticImport
      */
     Token offendingToken = ctx.getToken(DroppingJavaParser.IMPORT, 0).getSymbol();
     String offendingImportString = String.format("import static %s.*;", ctx.typeName().getText());
-    System.out.printf("WARNING: Static imports on demand are not " +
-            "supported. If they are used in not ignored methods please replace " +
-            "them with a set of single static imports.\nLine %d:%d - %s\n",
+    log.warn("Static imports on demand are not supported. If they are used in not ignored methods please replace " +
+            "them with a set of single static imports.\nLine {}:{} - {}\n",
             offendingToken.getLine(), offendingToken.getCharPositionInLine(), offendingImportString);
   }
 
@@ -317,7 +319,7 @@ private String extractCutpointString(ParserRuleContext ctx) {
       return assembler.getTagValue();
 
     } catch (Exception e) {   // we can't be sure about anything in comments so that we need a defense line
-      System.out.printf("Couldn't extract cutpoint from javadoc comments: '%s'. Falling back to default.\n", e.getMessage());
+      log.info("Couldn't extract cutpoint from javadoc comments: '{}'. Falling back to default.", e.getMessage());
       return null;
     }
   }
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/DropletLoaderTest.java b/src/test/java/ru/ftc/upc/testing/dropper/DropletLoaderTest.java
index b625d58..67fdb64 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/DropletLoaderTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/DropletLoaderTest.java
@@ -1,18 +1,21 @@
 package ru.ftc.upc.testing.dropper;
 
 import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import ru.ftc.upc.testing.dropper.model.TargetsMap;
 
 /**
  * @author Toparvion
  */
 public class DropletLoaderTest {
+  private static final Logger log = LoggerFactory.getLogger(DropletLoaderTest.class);
 
   @Test
   public void loadDroplets() throws Exception {
     String args = "src/test/resources/DPClientImpl.java;src/test/resources/DPClientImpl2.java";
     TargetsMap targetsMap = DropletLoader.loadDroplets(args);
-    System.out.printf("Targets map:\n%s", targetsMap.toString());
+    log.info("Targets map:\n{}", targetsMap.toString());
   }
 
 }
\ No newline at end of file
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/CutpointAssemblerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/CutpointAssemblerTest.java
index ab066fb..d97fe3e 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/CutpointAssemblerTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/CutpointAssemblerTest.java
@@ -6,6 +6,8 @@
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.ParseTreeWalker;
 import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import ru.ftc.upc.testing.dropper.Cutpoint;
 import ru.ftc.upc.testing.dropper.lang.gen.JavadocLexer;
 import ru.ftc.upc.testing.dropper.lang.gen.JavadocParser;
@@ -19,13 +21,14 @@
  * @author Toparvion
  */
 public class CutpointAssemblerTest {
+  static final Logger log = LoggerFactory.getLogger(CutpointAssemblerTest.class); 
 
   @Test
   public void cutpoint1IsRecognizedCorrectly() throws Exception {
     CutpointAssembler cutpointAssembler = loadJavadoc("src/test/resources/Cutpoint_1.javadoc");
     String tagValue = cutpointAssembler.getTagValue();
     Cutpoint cutpoint = Cutpoint.valueOf(tagValue.toUpperCase());
-    System.out.printf("Cutpoint 1: '%s'\n", tagValue);
+    log.info("Cutpoint 1: '{}'", tagValue);
     assertEquals(Cutpoint.BEFORE, cutpoint);
   }
 
@@ -34,7 +37,7 @@ public void cutpoint2IsRecognizedCorrectly() throws Exception {
     CutpointAssembler cutpointAssembler = loadJavadoc("src/test/resources/Cutpoint_2.javadoc");
     String tagValue = cutpointAssembler.getTagValue();
     Cutpoint cutpoint = Cutpoint.valueOf(tagValue.toUpperCase());
-    System.out.printf("Cutpoint 2: '%s'\n", tagValue);
+    log.info("Cutpoint 2: '{}'", tagValue);
     assertEquals(Cutpoint.CATCH, cutpoint);
   }
 
@@ -43,7 +46,7 @@ public void cutpoint3IsRecognizedCorrectly() throws Exception {
     CutpointAssembler cutpointAssembler = loadJavadoc("src/test/resources/Cutpoint_3.javadoc");
     String tagValue = cutpointAssembler.getTagValue();
     Cutpoint cutpoint = Cutpoint.valueOf(tagValue.toUpperCase());
-    System.out.printf("Cutpoint 3: '%s'\n", tagValue);
+    log.info("Cutpoint 3: '{}'", tagValue);
     assertEquals(Cutpoint.INSTEAD, cutpoint);
   }
 
@@ -52,7 +55,7 @@ public void cutpoint4IsRecognizedCorrectly() throws Exception {
     CutpointAssembler cutpointAssembler = loadJavadoc("src/test/resources/Cutpoint_4.javadoc");
     String tagValue = cutpointAssembler.getTagValue();
     Cutpoint cutpoint = Cutpoint.valueOf(tagValue.toUpperCase());
-    System.out.printf("Cutpoint 4: '%s'\n", tagValue);
+    log.info("Cutpoint 4: '{}'", tagValue);
     assertEquals(Cutpoint.AFTER, cutpoint);
   }
 
@@ -60,7 +63,7 @@ public void cutpoint4IsRecognizedCorrectly() throws Exception {
   public void cutpoint5IsRecognizedCorrectly() throws Exception {
     CutpointAssembler cutpointAssembler = loadJavadoc("src/test/resources/Cutpoint_5.javadoc");
     String tagValue = cutpointAssembler.getTagValue();
-    System.out.printf("Cutpoint 5: '%s'\n", tagValue);
+    log.info("Cutpoint 5: '{}'", tagValue);
     assertNull(tagValue);
   }
 
@@ -69,7 +72,7 @@ public void cutpoint6IsRecognizedCorrectly() throws Exception {
     CutpointAssembler cutpointAssembler = loadJavadoc("src/test/resources/Cutpoint_6.javadoc");
     String tagValue = cutpointAssembler.getTagValue();
     Cutpoint cutpoint = Cutpoint.valueOf(tagValue.toUpperCase());
-    System.out.printf("Cutpoint 6: '%s'\n", tagValue);
+    log.info("Cutpoint 6: '{}'", tagValue);
     assertEquals(Cutpoint.IGNORE, cutpoint);
   }
 
@@ -78,7 +81,7 @@ public void cutpoint7IsRecognizedCorrectly() throws Exception {
     CutpointAssembler cutpointAssembler = loadJavadoc("src/test/resources/Cutpoint_7.javadoc");
     String tagValue = cutpointAssembler.getTagValue();
     Cutpoint cutpoint = Cutpoint.valueOf(tagValue.toUpperCase());
-    System.out.printf("Cutpoint 7: '%s'\n", tagValue);
+    log.info("Cutpoint 7: '{}'", tagValue);
     assertEquals(Cutpoint.IGNORE, cutpoint);
   }
 
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
index c2ca3c9..3313ad5 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
+++ b/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
@@ -6,6 +6,8 @@
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.ParseTreeWalker;
 import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import ru.ftc.upc.testing.dropper.Cutpoint;
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaLexer;
 import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
@@ -21,13 +23,14 @@
  * @author Toparvion
  */
 public class DropletAssemblerTest {
+  private static final Logger log = LoggerFactory.getLogger(DropletAssemblerTest.class);
 
   @Test
   public void nestedClassesAreRecognizedFully() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
-    System.out.println(actual);
+    log.debug(actual);
     String expected = "ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\t{ return 1 ; }\n" +
@@ -65,7 +68,7 @@ public void methodHeadersAreRecognizedFully() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
-    System.out.println(actual);
+    log.debug(actual);
     String expected = "ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders -> {\n" +
             "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(),\n" +
             "\t\timportsOnDemand=(java.util), text=(empty)}\n" +
@@ -112,7 +115,7 @@ public void methodBodiesAreRecognizedFully() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MethodBodies.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
-    System.out.println(actual);
+    log.debug(actual);
     String expected = "ru/ftc/upc/testing/dropper/lang/samples/MethodBodies -> {\n" +
             "\tTargetMethod{name='MethodBodies', cutpoint=INSTEAD, resultType=null, formalParams=(String name), text=\n" +
             "\t\t{ System . out . println ( \"Hello from constructor :) \" ) ; }\n" +
@@ -130,7 +133,7 @@ public void enumTypesAreRecognizedFully() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/RootEnumeration.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
-    System.out.println(actual);
+    log.debug(actual);
     String expected = "ru/ftc/upc/testing/dropper/lang/samples/RootEnumeration -> {\n" +
             "\tTargetMethod{name='RootEnumeration', cutpoint=INSTEAD, resultType=null, formalParams=(), text=\n" +
             "\t\t{ String nothing = \"I'm the most enumerated constructor ever!\" ; }\n" +
@@ -152,7 +155,7 @@ public void interfaceTypesAreRecognizedFully() throws Exception {
     String dropletPath = "src/test/resources/RootInterface.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
-    System.out.println(actual);
+    log.debug(actual);
     String expected = "ru/ftc/upc/testing/dropper/lang/RootInterface -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "\tTargetMethod{name='method2', cutpoint=INSTEAD, resultType=boolean, formalParams=(int two), text=(empty)}\n" +
@@ -182,7 +185,7 @@ public void typesCombinationsAreRecognizedFully() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/TypesCombination.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
-    System.out.println(actual);
+    log.debug(actual);
     String expected = "ru/ftc/upc/testing/dropper/lang/samples/TypesCombination -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=\n" +
             "\t\t{ System . console ( ) ; }\n" +
@@ -230,12 +233,12 @@ public void importMapIsComposedCorrectly() throws Exception {
             "\tMAX_VALUE -> java.lang.Integer\n" +
             "\trandom -> java.lang.Math\n";
     String actualImportsMap = map2Str(importsMap);
-    System.out.println(actualImportsMap);
+    log.debug(actualImportsMap);
     assertEquals(expectedImportsMap, actualImportsMap);
 
     TargetsMap targetsMap = dropletAssembler.getTargetsMap();
     String actualTargetsMap = targetsMap.toString();
-    System.out.println(actualTargetsMap);
+    log.debug(actualTargetsMap);
     String expectedTargetsMap = "ru/ftc/upc/testing/dropper/lang/samples/Imports -> {\n" +
             "\tTargetMethod{name='Imports', cutpoint=INSTEAD, resultType=null, formalParams=(),\n" +
             "\t\timportsOnDemand=(java.math), text=\n" +
@@ -250,7 +253,7 @@ public void afterCutpointIsRecognizedFully() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/AfterCutpoint.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     Cutpoint actual = targetsMap.entrySet().iterator().next().getValue().getFirst().getCutpoint();
-    System.out.printf("Actual cutpoint: %s\n", actual);
+    log.debug("Actual cutpoint: {}", actual);
     assertEquals(Cutpoint.AFTER, actual);
   }
 
@@ -259,7 +262,7 @@ public void defaultCutpointIsAppliedCorrectly() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DefaultCutpoint.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     Cutpoint actual = targetsMap.entrySet().iterator().next().getValue().getFirst().getCutpoint();
-    System.out.printf("Actual cutpoint (default): %s\n", actual);
+    log.debug("Actual cutpoint (default): {}", actual);
     assertEquals(Cutpoint.INSTEAD, actual);
   }
 
@@ -268,7 +271,7 @@ public void typeNamesInMethodBodiesAreResolvedCorrectly() throws Exception {
     String dropletPath = "src/test/resources/DPClientImpl.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
-    System.out.println(actual);
+    log.debug(actual);
     String expected = "dp/DPClientImpl -> {\n" +
             "\tTargetMethod{name='currencyRate', cutpoint=INSTEAD, resultType=dp.models.QuickPay$AnsCurrencyRate, formalParams=(dp.models.QuickPay$ReqCurrencyRate reqCurrencyRate), text=\n" +
             "\t\t{ try { java.io.FileReader stubReader = new java.io.FileReader ( System . getProperty ( \"user.dir\" ) + java.io.File . separator + \"AnsCurrencyRate.xml\" ) ; javax.xml.bind.Unmarshaller unmarshaller = quickPayJbcDoc . createUnmarshaller ( ) ; dp.models.QuickPay quickPay = ( dp.models.QuickPay ) unmarshaller . unmarshal ( stubReader ) ; log . info ( \"Rates were loaded from file AnsCurrencyRate.xml.\" ) ; stubReader . close ( ) ; return quickPay . getInfoService ( ) . getAnsCurrencyRate ( ) ; } catch ( Exception e ) { log . error ( \"Unable to load rates from file. Falling back to real service.\" , e ) ; dp . models . QuickPay quickPay = dp.models.QuickPay . infoService ( ) ; quickPay . getInfoService ( ) . setReqCurrencyRate ( $1 ) ; quickPay = sendQuickPay ( quickPay , false , false ) ; dp.models.QuickPay . AnsCurrencyRate ans = quickPay . getInfoService ( ) . getAnsCurrencyRate ( ) ; return ans ; } }\n" +
@@ -282,7 +285,7 @@ public void methodArgumentTypesAreResolvedCorrectly() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/NestedTypesAmongMethodArguments.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
-    System.out.println(actual);
+    log.debug(actual);
 
     String expected = "ru/ftc/upc/testing/dropper/lang/samples/NestedTypesAmongMethodArguments -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=java.util.Map$Entry, formalParams=(java.security.KeyStore$SecretKeyEntry arg), text=\n" +
@@ -297,7 +300,7 @@ public void formalParamReferencesAreObfuscatedCorrectly() throws Exception {
     String dropletPath = "src/test/resources/DPClientImpl2.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
-    System.out.println(actual);
+    log.debug(actual);
     String expected = "dp/DPClientImpl -> {\n" +
             "\tTargetMethod{name='fetchTransferStatus', cutpoint=INSTEAD, resultType=String, formalParams=(String oID, boolean needFlag), text=\n" +
             "\t\t{ String statusStr = null ; try { java.util.Properties stub = new java.util.Properties ( ) ; stub . load ( new java.io.FileReader ( System . getProperty ( \"user.dir\" ) + java.io.File . separator + \"dp-edit-mock.properties\" ) ) ; statusStr = stub . getProperty ( $1 ) ; if ( statusStr != null ) { statusStr = statusStr . trim ( ) ; log . warn ( \"For STRoID={} transfer status '{}' was taken from mock.\" , $1 , statusStr ) ; } } catch ( java.io.IOException e ) { log . error ( \"Failed to load mocked transfer edit statuses.\" , e ) ; } if ( statusStr == null ) { dp.models.QuickPay quickPay = dp.models.QuickPay . infoService ( ) ; dp.models.ReqTransferSearch req = new dp.models.ReqTransferSearch ( ) ; req . setOID ( getReserve ( ) . oID ) ; quickPay . getInfoService ( ) . setReqTransferSearch ( req ) ; quickPay = sendQuickPay ( quickPay , false , $2 ) ; statusStr = quickPay . getInfoService ( ) . getAnsTransferSearch ( ) . getTransferStatus ( ) ; } return statusStr ; }\n" +
@@ -311,7 +314,7 @@ public void dropletSuffixIsOmittedCorrectly() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffixDroplet.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
-    System.out.println(actual);
+    log.debug(actual);
 
     String expected = "ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffix -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
@@ -336,8 +339,7 @@ public void methodDuplicatesAreDetectedCorrectly() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DuplicatedMethodsDetection.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
-    System.out.println(actual);
-
+    log.debug(actual);
   }
 
   @Test(expected = DropletFormatException.class)
@@ -345,7 +347,7 @@ public void parametrizedMethodsAreNotSupported() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
-    System.out.println(actual);
+    log.debug(actual);
   }
 
   /**
@@ -356,7 +358,7 @@ public void parametrizedParametersInMethodsAreNotSupported() throws Exception {
     String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass2.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
-    System.out.println(actual);
+    log.debug(actual);
   }
 
   private DropletAssembler loadDroplet(String dropletPath) throws IOException {

From d9d5eaf1ef0503deb950ccf9511215b251c2856e Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Fri, 8 Jul 2016 00:43:24 +0600
Subject: [PATCH 19/22] 1. Migrated root package to 'tech.toparvion.jmint'; 2.
 Renamed the tool to 'JMint'

---
 build.gradle                                  | 13 +--
 settings.gradle                               |  2 +-
 .../dropper/lang/DropletFormatException.java  | 10 ---
 .../toparvion/jmint}/Cutpoint.java            | 10 +--
 .../toparvion/jmint}/DropletChecker.java      |  5 +-
 .../toparvion/jmint/JMintAgent.java}          | 31 +++----
 .../toparvion/jmint/TargetsTransformer.java}  | 18 ++--
 .../jmint}/lang/BodyComposingVisitor.java     |  4 +-
 .../jmint}/lang/CutpointAssembler.java        |  6 +-
 .../jmint}/lang/DropletAssembler.java         | 18 ++--
 .../jmint/lang/DropletFormatException.java    | 10 +++
 .../toparvion/jmint/lang}/DropletLoader.java  | 15 ++--
 .../toparvion/jmint}/lang/DroppingJava.g4     |  0
 .../jmint}/lang/GenericTypeSearchVisitor.java |  6 +-
 .../toparvion/jmint}/lang/JavadocLexer.g4     |  0
 .../toparvion/jmint}/lang/JavadocParser.g4    |  0
 .../lang/PureTypeNameComposingVisitor.java    |  6 +-
 .../jmint}/lang/UnderlineErrorListener.java   |  4 +-
 .../jmint}/lang/gen/DroppingJava.tokens       |  0
 .../lang/gen/DroppingJavaBaseListener.java    |  2 +-
 .../lang/gen/DroppingJavaBaseVisitor.java     |  2 +-
 .../jmint}/lang/gen/DroppingJavaLexer.java    |  2 +-
 .../jmint}/lang/gen/DroppingJavaLexer.tokens  |  0
 .../jmint}/lang/gen/DroppingJavaListener.java |  2 +-
 .../jmint}/lang/gen/DroppingJavaParser.java   |  2 +-
 .../jmint}/lang/gen/DroppingJavaVisitor.java  |  2 +-
 .../jmint}/lang/gen/JavadocLexer.java         |  2 +-
 .../jmint}/lang/gen/JavadocLexer.tokens       |  0
 .../jmint}/lang/gen/JavadocParser.java        |  2 +-
 .../jmint}/lang/gen/JavadocParser.tokens      |  0
 .../lang/gen/JavadocParserBaseListener.java   |  2 +-
 .../lang/gen/JavadocParserBaseVisitor.java    |  2 +-
 .../lang/gen/JavadocParserListener.java       |  2 +-
 .../jmint}/lang/gen/JavadocParserVisitor.java |  2 +-
 .../toparvion/jmint}/model/Argument.java      |  2 +-
 .../toparvion/jmint}/model/TargetMethod.java  |  4 +-
 .../toparvion/jmint}/model/TargetsMap.java    |  2 +-
 .../jmint}/modify/AfterBodyModifier.java      |  2 +-
 .../jmint}/modify/BeforeBodyModifier.java     |  2 +-
 .../jmint}/modify/InsteadBodyModifier.java    |  2 +-
 .../jmint}/modify/MethodModifier.java         |  2 +-
 .../jmint}/lang/CutpointAssemblerTest.java    |  8 +-
 .../jmint}/lang/DropletAssemblerTest.java     | 90 +++++++++----------
 .../jmint/lang}/DropletLoaderTest.java        |  8 +-
 .../jmint}/lang/samples/AfterCutpoint.java    |  2 +-
 .../lang/samples/ClassWithSuffixDroplet.java  |  2 +-
 .../jmint}/lang/samples/DefaultCutpoint.java  |  2 +-
 .../samples/DuplicatedMethodsDetection.java   |  2 +-
 .../jmint}/lang/samples/GenericClass.java     |  2 +-
 .../jmint}/lang/samples/GenericClass2.java    |  2 +-
 .../jmint}/lang/samples/MethodBodies.java     |  2 +-
 .../lang/samples/MultiNestedClasses.java      |  2 +-
 .../NestedTypesAmongMethodArguments.java      |  2 +-
 .../jmint}/lang/samples/RootEnumeration.java  |  2 +-
 .../jmint}/lang/samples/TypesCombination.java |  2 +-
 .../lang/samples/VariousMethodHeaders.java    |  2 +-
 .../resources/FaultyTypesCombination.java     |  2 +
 src/test/resources/Imports.java               |  2 +-
 src/test/resources/RootInterface.java         |  2 +-
 59 files changed, 170 insertions(+), 164 deletions(-)
 delete mode 100644 src/main/java/ru/ftc/upc/testing/dropper/lang/DropletFormatException.java
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/Cutpoint.java (82%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/DropletChecker.java (88%)
 rename src/main/java/{ru/ftc/upc/testing/dropper/DropperAgent.java => tech/toparvion/jmint/JMintAgent.java} (52%)
 rename src/main/java/{ru/ftc/upc/testing/dropper/PatchingTransformer.java => tech/toparvion/jmint/TargetsTransformer.java} (92%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/BodyComposingVisitor.java (83%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/CutpointAssembler.java (84%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/DropletAssembler.java (97%)
 create mode 100644 src/main/java/tech/toparvion/jmint/lang/DropletFormatException.java
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint/lang}/DropletLoader.java (82%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/DroppingJava.g4 (100%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/GenericTypeSearchVisitor.java (78%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/JavadocLexer.g4 (100%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/JavadocParser.g4 (100%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/PureTypeNameComposingVisitor.java (84%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/UnderlineErrorListener.java (94%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/gen/DroppingJava.tokens (100%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/gen/DroppingJavaBaseListener.java (99%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/gen/DroppingJavaBaseVisitor.java (99%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/gen/DroppingJavaLexer.java (99%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/gen/DroppingJavaLexer.tokens (100%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/gen/DroppingJavaListener.java (99%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/gen/DroppingJavaParser.java (99%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/gen/DroppingJavaVisitor.java (99%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/gen/JavadocLexer.java (99%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/gen/JavadocLexer.tokens (100%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/gen/JavadocParser.java (99%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/gen/JavadocParser.tokens (100%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/gen/JavadocParserBaseListener.java (99%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/gen/JavadocParserBaseVisitor.java (99%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/gen/JavadocParserListener.java (99%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/gen/JavadocParserVisitor.java (99%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/model/Argument.java (91%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/model/TargetMethod.java (96%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/model/TargetsMap.java (98%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/modify/AfterBodyModifier.java (88%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/modify/BeforeBodyModifier.java (88%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/modify/InsteadBodyModifier.java (88%)
 rename src/main/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/modify/MethodModifier.java (84%)
 rename src/test/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/CutpointAssemblerTest.java (94%)
 rename src/test/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/DropletAssemblerTest.java (82%)
 rename src/test/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint/lang}/DropletLoaderTest.java (66%)
 rename src/test/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/samples/AfterCutpoint.java (89%)
 rename src/test/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/samples/ClassWithSuffixDroplet.java (88%)
 rename src/test/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/samples/DefaultCutpoint.java (89%)
 rename src/test/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/samples/DuplicatedMethodsDetection.java (90%)
 rename src/test/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/samples/GenericClass.java (89%)
 rename src/test/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/samples/GenericClass2.java (88%)
 rename src/test/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/samples/MethodBodies.java (88%)
 rename src/test/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/samples/MultiNestedClasses.java (89%)
 rename src/test/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/samples/NestedTypesAmongMethodArguments.java (87%)
 rename src/test/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/samples/RootEnumeration.java (92%)
 rename src/test/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/samples/TypesCombination.java (95%)
 rename src/test/java/{ru/ftc/upc/testing/dropper => tech/toparvion/jmint}/lang/samples/VariousMethodHeaders.java (94%)

diff --git a/build.gradle b/build.gradle
index d4ef1ed..ea38c24 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,5 +1,5 @@
-group 'FTC-Prepaid'
-version '1.0'
+group 'toparvion'
+version '1.1'
 
 apply plugin: 'java'
 
@@ -26,10 +26,11 @@ dependencies {
 
 jar {
     manifest {
-        attributes("Implementation-Title": "Dropper",
+        attributes("Implementation-Title": "JMint",
                 "Implementation-Version": version,
-                "Premain-Class": "ru.ftc.upc.testing.dropper.DropperAgent",
-                "Main-Class": "ru.ftc.upc.testing.dropper.DropletChecker")
+                "Implementation-Vendor": "Toparvion",
+                "Premain-Class": "tech.toparvion.jmint.JMintAgent",
+                "Main-Class": "tech.toparvion.jmint.DropletChecker")
     }
     from {
         (configurations.runtime - configurations.provided)
@@ -43,7 +44,7 @@ task runPainterWithDebug(type: JavaExec, dependsOn: jar) {
             project.files('src/test/java/sampleapp/standalone/painter/slf4j-simple-1.7.7.jar')*/
     main 'sampleapp.standalone.painter.Painter'
     jvmArgs = ['-Dfile.encoding=UTF8',
-               '-javaagent:build/libs/dropper-1.0.jar=' +
+               '-javaagent:build/libs/jmint-'+version+'.jar=' +
                        'src/test/java/sampleapp/standalone/painter/DrawPaneDroplet.java;' +
                        'src/test/java/sampleapp/standalone/painter/PainterDroplet.java;' +
                        'src/test/resources/JFrameDroplet.java'
diff --git a/settings.gradle b/settings.gradle
index 6b0fc2b..6af93e4 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -1,2 +1,2 @@
-rootProject.name = 'dropper'
+rootProject.name = 'jmint'
 
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletFormatException.java b/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletFormatException.java
deleted file mode 100644
index 55e6f73..0000000
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletFormatException.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package ru.ftc.upc.testing.dropper.lang;
-
-/**
- * @author Toparvion
- */
-public class DropletFormatException extends RuntimeException {
-  public DropletFormatException(String message) {
-    super(message);
-  }
-}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java b/src/main/java/tech/toparvion/jmint/Cutpoint.java
similarity index 82%
rename from src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java
rename to src/main/java/tech/toparvion/jmint/Cutpoint.java
index 6a95df6..2101122 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/Cutpoint.java
+++ b/src/main/java/tech/toparvion/jmint/Cutpoint.java
@@ -1,9 +1,9 @@
-package ru.ftc.upc.testing.dropper;
+package tech.toparvion.jmint;
 
-import ru.ftc.upc.testing.dropper.modify.AfterBodyModifier;
-import ru.ftc.upc.testing.dropper.modify.BeforeBodyModifier;
-import ru.ftc.upc.testing.dropper.modify.InsteadBodyModifier;
-import ru.ftc.upc.testing.dropper.modify.MethodModifier;
+import tech.toparvion.jmint.modify.AfterBodyModifier;
+import tech.toparvion.jmint.modify.BeforeBodyModifier;
+import tech.toparvion.jmint.modify.InsteadBodyModifier;
+import tech.toparvion.jmint.modify.MethodModifier;
 
 /**
  * Created by Toparvion on 29.04.2016 11:59
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/DropletChecker.java b/src/main/java/tech/toparvion/jmint/DropletChecker.java
similarity index 88%
rename from src/main/java/ru/ftc/upc/testing/dropper/DropletChecker.java
rename to src/main/java/tech/toparvion/jmint/DropletChecker.java
index 88b214f..0a205be 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/DropletChecker.java
+++ b/src/main/java/tech/toparvion/jmint/DropletChecker.java
@@ -1,6 +1,7 @@
-package ru.ftc.upc.testing.dropper;
+package tech.toparvion.jmint;
 
-import ru.ftc.upc.testing.dropper.model.TargetsMap;
+import tech.toparvion.jmint.lang.DropletLoader;
+import tech.toparvion.jmint.model.TargetsMap;
 
 /**
  * @author Toparvion
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java b/src/main/java/tech/toparvion/jmint/JMintAgent.java
similarity index 52%
rename from src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java
rename to src/main/java/tech/toparvion/jmint/JMintAgent.java
index 5445cce..8df6c29 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/DropperAgent.java
+++ b/src/main/java/tech/toparvion/jmint/JMintAgent.java
@@ -1,8 +1,9 @@
-package ru.ftc.upc.testing.dropper;
+package tech.toparvion.jmint;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import ru.ftc.upc.testing.dropper.model.TargetsMap;
+import tech.toparvion.jmint.lang.DropletLoader;
+import tech.toparvion.jmint.model.TargetsMap;
 
 import java.lang.instrument.Instrumentation;
 
@@ -10,13 +11,13 @@
  * Created by Toparvion on 28.04.2016 9:13
  */
 @SuppressWarnings({"unused", "WeakerAccess"}) // the class is used by Java Instrumentation API and thus must be public
-public class DropperAgent {
-  private static final Logger log = LoggerFactory.getLogger(DropperAgent.class);
+public class JMintAgent {
+  private static final Logger log = LoggerFactory.getLogger(JMintAgent.class);
 
   public static void premain(String agentArgs, Instrumentation inst) {
-    System.out.println(DROPPER_LOGO);
+    System.out.println(JMINT_LOGO);
 
-    Package pack = DropperAgent.class.getPackage();
+    Package pack = JMintAgent.class.getPackage();
     log.info("{} started (version: {}).", pack.getImplementationTitle(), pack.getImplementationVersion());
 
     long startTime = System.currentTimeMillis();
@@ -27,18 +28,18 @@ public static void premain(String agentArgs, Instrumentation inst) {
     if (targetsMap.isEmpty()) {
       log.warn("No droplets to apply left after arguments processing. No byte code will be modified.");
     } else {
-      inst.addTransformer(new PatchingTransformer(targetsMap));
+      inst.addTransformer(new TargetsTransformer(targetsMap));
     }
   }
 
   //<editor-fold desc="Logo">
-  private static final String DROPPER_LOGO =
-    "     _____                                     \n" +
-    "    (____ \\                                    \n" +
-    "     _   \\ \\ ____ ___  ____  ____   ____  ____ \n" +
-    "    | |   | / ___) _ \\|  _ \\|  _ \\ / _  )/ ___)\n" +
-    "    | |__/ / |  | |_| | | | | | | ( (/ /| |    \n" +
-    "    |_____/|_|   \\___/| ||_/| ||_/ \\____)_|    \n" +
-    "                      |_|   |_|                ";
+  private static final String JMINT_LOGO =
+        "     _   ____    ____    _               _    \n" +
+        "    (_) |_   \\  /   _|  (_)             / |_  \n" +
+        "    __    |   \\/   |    __    _ .--.   `| |-' \n" +
+        "   [  |   | |\\  /| |   [  |  [ `.-. |   | |   \n" +
+        " _  | |  _| |_\\/_| |_   | |   | | | |   | |,  \n" +
+        "[ \\_| | |_____||_____| [___] [___||__]  \\__/  \n" +
+        " \\____/                                       ";
   //</editor-fold>
 }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java b/src/main/java/tech/toparvion/jmint/TargetsTransformer.java
similarity index 92%
rename from src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java
rename to src/main/java/tech/toparvion/jmint/TargetsTransformer.java
index e7a1aa4..4c1105f 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/PatchingTransformer.java
+++ b/src/main/java/tech/toparvion/jmint/TargetsTransformer.java
@@ -1,12 +1,12 @@
-package ru.ftc.upc.testing.dropper;
+package tech.toparvion.jmint;
 
 import javassist.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import ru.ftc.upc.testing.dropper.model.Argument;
-import ru.ftc.upc.testing.dropper.model.TargetMethod;
-import ru.ftc.upc.testing.dropper.model.TargetsMap;
-import ru.ftc.upc.testing.dropper.modify.MethodModifier;
+import tech.toparvion.jmint.model.Argument;
+import tech.toparvion.jmint.model.TargetMethod;
+import tech.toparvion.jmint.model.TargetsMap;
+import tech.toparvion.jmint.modify.MethodModifier;
 
 import java.lang.instrument.ClassFileTransformer;
 import java.lang.instrument.IllegalClassFormatException;
@@ -14,13 +14,13 @@
 import java.util.*;
 
 import static java.lang.String.format;
-import static ru.ftc.upc.testing.dropper.Cutpoint.IGNORE;
+import static tech.toparvion.jmint.Cutpoint.IGNORE;
 
 /**
  * Created by Toparvion on 29.04.2016 12:50
  */
-class PatchingTransformer implements ClassFileTransformer {
-  private static final Logger log = LoggerFactory.getLogger(PatchingTransformer.class);
+class TargetsTransformer implements ClassFileTransformer {
+  private static final Logger log = LoggerFactory.getLogger(TargetsTransformer.class);
 
   /**
    * The package that is implicitly imported into every Javassist ClassPool instance and therefore should be considered
@@ -33,7 +33,7 @@ class PatchingTransformer implements ClassFileTransformer {
   private final Set<ClassLoader> knownLoaders = new HashSet<ClassLoader>();
   private final Set<String> knownPackages = new HashSet<String>();
 
-  PatchingTransformer(TargetsMap targetsMap) {
+  TargetsTransformer(TargetsMap targetsMap) {
     this.targetsMap = targetsMap;
     this.pool = ClassPool.getDefault();
   }
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/BodyComposingVisitor.java b/src/main/java/tech/toparvion/jmint/lang/BodyComposingVisitor.java
similarity index 83%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/BodyComposingVisitor.java
rename to src/main/java/tech/toparvion/jmint/lang/BodyComposingVisitor.java
index dc29e45..a62a004 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/BodyComposingVisitor.java
+++ b/src/main/java/tech/toparvion/jmint/lang/BodyComposingVisitor.java
@@ -1,7 +1,7 @@
-package ru.ftc.upc.testing.dropper.lang;
+package tech.toparvion.jmint.lang;
 
 import org.antlr.v4.runtime.tree.TerminalNode;
-import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaBaseVisitor;
+import tech.toparvion.jmint.lang.gen.DroppingJavaBaseVisitor;
 
 /**
  * A parse tree visitor for assembling all the child terminal node's texts into single string separated with spaces.
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/CutpointAssembler.java b/src/main/java/tech/toparvion/jmint/lang/CutpointAssembler.java
similarity index 84%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/CutpointAssembler.java
rename to src/main/java/tech/toparvion/jmint/lang/CutpointAssembler.java
index 7adb5a0..4df5093 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/CutpointAssembler.java
+++ b/src/main/java/tech/toparvion/jmint/lang/CutpointAssembler.java
@@ -1,7 +1,7 @@
-package ru.ftc.upc.testing.dropper.lang;
+package tech.toparvion.jmint.lang;
 
-import ru.ftc.upc.testing.dropper.lang.gen.JavadocParser;
-import ru.ftc.upc.testing.dropper.lang.gen.JavadocParserBaseListener;
+import tech.toparvion.jmint.lang.gen.JavadocParser;
+import tech.toparvion.jmint.lang.gen.JavadocParserBaseListener;
 
 import java.util.List;
 
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java b/src/main/java/tech/toparvion/jmint/lang/DropletAssembler.java
similarity index 97%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
rename to src/main/java/tech/toparvion/jmint/lang/DropletAssembler.java
index 04199c3..b5d0ee1 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/DropletAssembler.java
+++ b/src/main/java/tech/toparvion/jmint/lang/DropletAssembler.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang;
+package tech.toparvion.jmint.lang;
 
 import org.antlr.v4.runtime.*;
 import org.antlr.v4.runtime.tree.ParseTree;
@@ -6,26 +6,26 @@
 import org.antlr.v4.runtime.tree.TerminalNode;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import ru.ftc.upc.testing.dropper.Cutpoint;
-import ru.ftc.upc.testing.dropper.lang.gen.*;
-import ru.ftc.upc.testing.dropper.model.Argument;
-import ru.ftc.upc.testing.dropper.model.TargetMethod;
-import ru.ftc.upc.testing.dropper.model.TargetsMap;
+import tech.toparvion.jmint.Cutpoint;
+import tech.toparvion.jmint.lang.gen.*;
+import tech.toparvion.jmint.model.Argument;
+import tech.toparvion.jmint.model.TargetMethod;
+import tech.toparvion.jmint.model.TargetsMap;
 
 import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import static java.util.regex.Matcher.quoteReplacement;
-import static ru.ftc.upc.testing.dropper.Cutpoint.IGNORE;
+import static tech.toparvion.jmint.Cutpoint.IGNORE;
 
 /**
  * The main class responsible for extracting valuable data from droplet files. Built upon ANTLR parse tree event
  * listener.
  * @author Toparvion
  */
-public class DropletAssembler extends DroppingJavaBaseListener {
-  static final Logger log = LoggerFactory.getLogger(DropletAssembler.class);
+class DropletAssembler extends DroppingJavaBaseListener {
+  private static final Logger log = LoggerFactory.getLogger(DropletAssembler.class);
 
   /**
    * Mapping between all target classes and lists of their methods. These methods are targets for byte
diff --git a/src/main/java/tech/toparvion/jmint/lang/DropletFormatException.java b/src/main/java/tech/toparvion/jmint/lang/DropletFormatException.java
new file mode 100644
index 0000000..4428734
--- /dev/null
+++ b/src/main/java/tech/toparvion/jmint/lang/DropletFormatException.java
@@ -0,0 +1,10 @@
+package tech.toparvion.jmint.lang;
+
+/**
+ * @author Toparvion
+ */
+class DropletFormatException extends RuntimeException {
+  DropletFormatException(String message) {
+    super(message);
+  }
+}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/DropletLoader.java b/src/main/java/tech/toparvion/jmint/lang/DropletLoader.java
similarity index 82%
rename from src/main/java/ru/ftc/upc/testing/dropper/DropletLoader.java
rename to src/main/java/tech/toparvion/jmint/lang/DropletLoader.java
index b85a72b..c1986a1 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/DropletLoader.java
+++ b/src/main/java/tech/toparvion/jmint/lang/DropletLoader.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper;
+package tech.toparvion.jmint.lang;
 
 import org.antlr.v4.runtime.ANTLRFileStream;
 import org.antlr.v4.runtime.BufferedTokenStream;
@@ -8,22 +8,19 @@
 import org.antlr.v4.runtime.tree.ParseTreeWalker;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import ru.ftc.upc.testing.dropper.lang.DropletAssembler;
-import ru.ftc.upc.testing.dropper.lang.DropletFormatException;
-import ru.ftc.upc.testing.dropper.lang.UnderlineErrorListener;
-import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaLexer;
-import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
-import ru.ftc.upc.testing.dropper.model.TargetsMap;
+import tech.toparvion.jmint.lang.gen.DroppingJavaLexer;
+import tech.toparvion.jmint.lang.gen.DroppingJavaParser;
+import tech.toparvion.jmint.model.TargetsMap;
 
 import java.io.IOException;
 
 /**
  * @author Toparvion
  */
-abstract class DropletLoader {
+public abstract class DropletLoader {
   private static final Logger log = LoggerFactory.getLogger(DropletLoader.class);
 
-  static TargetsMap loadDroplets(String args) {
+  public static TargetsMap loadDroplets(String args) {
     String[] argTokens = args.split("[;,]");
     // at the moment we support only one argument file format - droplet format, thus file extension doesn't matter
     TargetsMap overallMap = new TargetsMap();
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4 b/src/main/java/tech/toparvion/jmint/lang/DroppingJava.g4
similarity index 100%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/DroppingJava.g4
rename to src/main/java/tech/toparvion/jmint/lang/DroppingJava.g4
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/GenericTypeSearchVisitor.java b/src/main/java/tech/toparvion/jmint/lang/GenericTypeSearchVisitor.java
similarity index 78%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/GenericTypeSearchVisitor.java
rename to src/main/java/tech/toparvion/jmint/lang/GenericTypeSearchVisitor.java
index 5b923ca..ce12ab0 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/GenericTypeSearchVisitor.java
+++ b/src/main/java/tech/toparvion/jmint/lang/GenericTypeSearchVisitor.java
@@ -1,9 +1,9 @@
-package ru.ftc.upc.testing.dropper.lang;
+package tech.toparvion.jmint.lang;
 
 import org.antlr.v4.runtime.ParserRuleContext;
 import org.antlr.v4.runtime.tree.RuleNode;
-import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaBaseVisitor;
-import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
+import tech.toparvion.jmint.lang.gen.DroppingJavaBaseVisitor;
+import tech.toparvion.jmint.lang.gen.DroppingJavaParser;
 
 /**
  * @author Toparvion
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/JavadocLexer.g4 b/src/main/java/tech/toparvion/jmint/lang/JavadocLexer.g4
similarity index 100%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/JavadocLexer.g4
rename to src/main/java/tech/toparvion/jmint/lang/JavadocLexer.g4
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/JavadocParser.g4 b/src/main/java/tech/toparvion/jmint/lang/JavadocParser.g4
similarity index 100%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/JavadocParser.g4
rename to src/main/java/tech/toparvion/jmint/lang/JavadocParser.g4
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/PureTypeNameComposingVisitor.java b/src/main/java/tech/toparvion/jmint/lang/PureTypeNameComposingVisitor.java
similarity index 84%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/PureTypeNameComposingVisitor.java
rename to src/main/java/tech/toparvion/jmint/lang/PureTypeNameComposingVisitor.java
index 31464da..212312b 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/PureTypeNameComposingVisitor.java
+++ b/src/main/java/tech/toparvion/jmint/lang/PureTypeNameComposingVisitor.java
@@ -1,8 +1,8 @@
-package ru.ftc.upc.testing.dropper.lang;
+package tech.toparvion.jmint.lang;
 
 import org.antlr.v4.runtime.tree.TerminalNode;
-import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaBaseVisitor;
-import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
+import tech.toparvion.jmint.lang.gen.DroppingJavaBaseVisitor;
+import tech.toparvion.jmint.lang.gen.DroppingJavaParser;
 
 /**
  * Simple visitor that assembles a string from all the terminal nodes excluding {@code typeArguments, annotation}
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/UnderlineErrorListener.java b/src/main/java/tech/toparvion/jmint/lang/UnderlineErrorListener.java
similarity index 94%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/UnderlineErrorListener.java
rename to src/main/java/tech/toparvion/jmint/lang/UnderlineErrorListener.java
index 17a1ca8..3eec4d1 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/UnderlineErrorListener.java
+++ b/src/main/java/tech/toparvion/jmint/lang/UnderlineErrorListener.java
@@ -1,8 +1,8 @@
-package ru.ftc.upc.testing.dropper.lang;
+package tech.toparvion.jmint.lang;
 
 import org.antlr.v4.runtime.*;
 
-public class UnderlineErrorListener extends BaseErrorListener {
+class UnderlineErrorListener extends BaseErrorListener {
 
   @Override
   public void syntaxError(Recognizer<?, ?> recognizer,
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJava.tokens b/src/main/java/tech/toparvion/jmint/lang/gen/DroppingJava.tokens
similarity index 100%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJava.tokens
rename to src/main/java/tech/toparvion/jmint/lang/gen/DroppingJava.tokens
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java b/src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaBaseListener.java
similarity index 99%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java
rename to src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaBaseListener.java
index 38f7ab3..509fa47 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseListener.java
+++ b/src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaBaseListener.java
@@ -1,5 +1,5 @@
 // Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\DroppingJava.g4 by ANTLR 4.5.1
-package ru.ftc.upc.testing.dropper.lang.gen;
+package tech.toparvion.jmint.lang.gen;
 
 import org.antlr.v4.runtime.ParserRuleContext;
 import org.antlr.v4.runtime.tree.ErrorNode;
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseVisitor.java b/src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaBaseVisitor.java
similarity index 99%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseVisitor.java
rename to src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaBaseVisitor.java
index 3332bdc..5e64021 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaBaseVisitor.java
+++ b/src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaBaseVisitor.java
@@ -1,5 +1,5 @@
 // Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\DroppingJava.g4 by ANTLR 4.5.1
-package ru.ftc.upc.testing.dropper.lang.gen;
+package tech.toparvion.jmint.lang.gen;
 import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
 
 /**
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.java b/src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaLexer.java
similarity index 99%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.java
rename to src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaLexer.java
index 06be9bc..fdcfbbd 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.java
+++ b/src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaLexer.java
@@ -1,5 +1,5 @@
 // Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\DroppingJava.g4 by ANTLR 4.5.1
-package ru.ftc.upc.testing.dropper.lang.gen;
+package tech.toparvion.jmint.lang.gen;
 import org.antlr.v4.runtime.*;
 import org.antlr.v4.runtime.atn.ATN;
 import org.antlr.v4.runtime.atn.ATNDeserializer;
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.tokens b/src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaLexer.tokens
similarity index 100%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaLexer.tokens
rename to src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaLexer.tokens
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java b/src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaListener.java
similarity index 99%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java
rename to src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaListener.java
index f6f32c9..b0c5ae6 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaListener.java
+++ b/src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaListener.java
@@ -1,5 +1,5 @@
 // Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\DroppingJava.g4 by ANTLR 4.5.1
-package ru.ftc.upc.testing.dropper.lang.gen;
+package tech.toparvion.jmint.lang.gen;
 import org.antlr.v4.runtime.tree.ParseTreeListener;
 
 /**
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java b/src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaParser.java
similarity index 99%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java
rename to src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaParser.java
index ed37fa0..27d4b78 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaParser.java
+++ b/src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaParser.java
@@ -1,5 +1,5 @@
 // Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\DroppingJava.g4 by ANTLR 4.5.1
-package ru.ftc.upc.testing.dropper.lang.gen;
+package tech.toparvion.jmint.lang.gen;
 
 import org.antlr.v4.runtime.*;
 import org.antlr.v4.runtime.atn.ATN;
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaVisitor.java b/src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaVisitor.java
similarity index 99%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaVisitor.java
rename to src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaVisitor.java
index 13babda..e9a02c1 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/DroppingJavaVisitor.java
+++ b/src/main/java/tech/toparvion/jmint/lang/gen/DroppingJavaVisitor.java
@@ -1,5 +1,5 @@
 // Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\DroppingJava.g4 by ANTLR 4.5.1
-package ru.ftc.upc.testing.dropper.lang.gen;
+package tech.toparvion.jmint.lang.gen;
 import org.antlr.v4.runtime.tree.ParseTreeVisitor;
 
 /**
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocLexer.java b/src/main/java/tech/toparvion/jmint/lang/gen/JavadocLexer.java
similarity index 99%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocLexer.java
rename to src/main/java/tech/toparvion/jmint/lang/gen/JavadocLexer.java
index 0174ed7..c9f6c9f 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocLexer.java
+++ b/src/main/java/tech/toparvion/jmint/lang/gen/JavadocLexer.java
@@ -1,5 +1,5 @@
 // Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\JavadocLexer.g4 by ANTLR 4.5.1
-package ru.ftc.upc.testing.dropper.lang.gen;
+package tech.toparvion.jmint.lang.gen;
 import org.antlr.v4.runtime.*;
 import org.antlr.v4.runtime.atn.ATN;
 import org.antlr.v4.runtime.atn.ATNDeserializer;
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocLexer.tokens b/src/main/java/tech/toparvion/jmint/lang/gen/JavadocLexer.tokens
similarity index 100%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocLexer.tokens
rename to src/main/java/tech/toparvion/jmint/lang/gen/JavadocLexer.tokens
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParser.java b/src/main/java/tech/toparvion/jmint/lang/gen/JavadocParser.java
similarity index 99%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParser.java
rename to src/main/java/tech/toparvion/jmint/lang/gen/JavadocParser.java
index e42d246..d8bd936 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParser.java
+++ b/src/main/java/tech/toparvion/jmint/lang/gen/JavadocParser.java
@@ -1,5 +1,5 @@
 // Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\JavadocParser.g4 by ANTLR 4.5.1
-package ru.ftc.upc.testing.dropper.lang.gen;
+package tech.toparvion.jmint.lang.gen;
 
 import org.antlr.v4.runtime.*;
 import org.antlr.v4.runtime.atn.ATN;
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParser.tokens b/src/main/java/tech/toparvion/jmint/lang/gen/JavadocParser.tokens
similarity index 100%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParser.tokens
rename to src/main/java/tech/toparvion/jmint/lang/gen/JavadocParser.tokens
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserBaseListener.java b/src/main/java/tech/toparvion/jmint/lang/gen/JavadocParserBaseListener.java
similarity index 99%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserBaseListener.java
rename to src/main/java/tech/toparvion/jmint/lang/gen/JavadocParserBaseListener.java
index 32e271a..d7543eb 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserBaseListener.java
+++ b/src/main/java/tech/toparvion/jmint/lang/gen/JavadocParserBaseListener.java
@@ -1,5 +1,5 @@
 // Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\JavadocParser.g4 by ANTLR 4.5.1
-package ru.ftc.upc.testing.dropper.lang.gen;
+package tech.toparvion.jmint.lang.gen;
 
 import org.antlr.v4.runtime.ParserRuleContext;
 import org.antlr.v4.runtime.tree.ErrorNode;
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserBaseVisitor.java b/src/main/java/tech/toparvion/jmint/lang/gen/JavadocParserBaseVisitor.java
similarity index 99%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserBaseVisitor.java
rename to src/main/java/tech/toparvion/jmint/lang/gen/JavadocParserBaseVisitor.java
index 431a34f..f588a90 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserBaseVisitor.java
+++ b/src/main/java/tech/toparvion/jmint/lang/gen/JavadocParserBaseVisitor.java
@@ -1,5 +1,5 @@
 // Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\JavadocParser.g4 by ANTLR 4.5.1
-package ru.ftc.upc.testing.dropper.lang.gen;
+package tech.toparvion.jmint.lang.gen;
 import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
 
 /**
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserListener.java b/src/main/java/tech/toparvion/jmint/lang/gen/JavadocParserListener.java
similarity index 99%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserListener.java
rename to src/main/java/tech/toparvion/jmint/lang/gen/JavadocParserListener.java
index 66655ab..5c4af5d 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserListener.java
+++ b/src/main/java/tech/toparvion/jmint/lang/gen/JavadocParserListener.java
@@ -1,5 +1,5 @@
 // Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\JavadocParser.g4 by ANTLR 4.5.1
-package ru.ftc.upc.testing.dropper.lang.gen;
+package tech.toparvion.jmint.lang.gen;
 import org.antlr.v4.runtime.tree.ParseTreeListener;
 
 /**
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserVisitor.java b/src/main/java/tech/toparvion/jmint/lang/gen/JavadocParserVisitor.java
similarity index 99%
rename from src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserVisitor.java
rename to src/main/java/tech/toparvion/jmint/lang/gen/JavadocParserVisitor.java
index e848b56..7925b2d 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/lang/gen/JavadocParserVisitor.java
+++ b/src/main/java/tech/toparvion/jmint/lang/gen/JavadocParserVisitor.java
@@ -1,5 +1,5 @@
 // Generated from C:/lang/dropper/src/main/java/ru/ftc/upc/testing/dropper/lang\JavadocParser.g4 by ANTLR 4.5.1
-package ru.ftc.upc.testing.dropper.lang.gen;
+package tech.toparvion.jmint.lang.gen;
 import org.antlr.v4.runtime.tree.ParseTreeVisitor;
 
 /**
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/Argument.java b/src/main/java/tech/toparvion/jmint/model/Argument.java
similarity index 91%
rename from src/main/java/ru/ftc/upc/testing/dropper/model/Argument.java
rename to src/main/java/tech/toparvion/jmint/model/Argument.java
index 2f5fb55..3ffd589 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/model/Argument.java
+++ b/src/main/java/tech/toparvion/jmint/model/Argument.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.model;
+package tech.toparvion.jmint.model;
 
 /**
  * @author Toparvion
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java b/src/main/java/tech/toparvion/jmint/model/TargetMethod.java
similarity index 96%
rename from src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
rename to src/main/java/tech/toparvion/jmint/model/TargetMethod.java
index 79b2993..7af0b65 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetMethod.java
+++ b/src/main/java/tech/toparvion/jmint/model/TargetMethod.java
@@ -1,6 +1,6 @@
-package ru.ftc.upc.testing.dropper.model;
+package tech.toparvion.jmint.model;
 
-import ru.ftc.upc.testing.dropper.Cutpoint;
+import tech.toparvion.jmint.Cutpoint;
 
 import java.util.LinkedList;
 import java.util.List;
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java b/src/main/java/tech/toparvion/jmint/model/TargetsMap.java
similarity index 98%
rename from src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java
rename to src/main/java/tech/toparvion/jmint/model/TargetsMap.java
index 66e5ff1..65acd5d 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/model/TargetsMap.java
+++ b/src/main/java/tech/toparvion/jmint/model/TargetsMap.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.model;
+package tech.toparvion.jmint.model;
 
 import java.util.*;
 
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/modify/AfterBodyModifier.java b/src/main/java/tech/toparvion/jmint/modify/AfterBodyModifier.java
similarity index 88%
rename from src/main/java/ru/ftc/upc/testing/dropper/modify/AfterBodyModifier.java
rename to src/main/java/tech/toparvion/jmint/modify/AfterBodyModifier.java
index 5d99f0a..2823fd1 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/modify/AfterBodyModifier.java
+++ b/src/main/java/tech/toparvion/jmint/modify/AfterBodyModifier.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.modify;
+package tech.toparvion.jmint.modify;
 
 import javassist.CannotCompileException;
 import javassist.CtBehavior;
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/modify/BeforeBodyModifier.java b/src/main/java/tech/toparvion/jmint/modify/BeforeBodyModifier.java
similarity index 88%
rename from src/main/java/ru/ftc/upc/testing/dropper/modify/BeforeBodyModifier.java
rename to src/main/java/tech/toparvion/jmint/modify/BeforeBodyModifier.java
index 616904e..96bf603 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/modify/BeforeBodyModifier.java
+++ b/src/main/java/tech/toparvion/jmint/modify/BeforeBodyModifier.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.modify;
+package tech.toparvion.jmint.modify;
 
 import javassist.CannotCompileException;
 import javassist.CtBehavior;
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/modify/InsteadBodyModifier.java b/src/main/java/tech/toparvion/jmint/modify/InsteadBodyModifier.java
similarity index 88%
rename from src/main/java/ru/ftc/upc/testing/dropper/modify/InsteadBodyModifier.java
rename to src/main/java/tech/toparvion/jmint/modify/InsteadBodyModifier.java
index 7246309..52c8983 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/modify/InsteadBodyModifier.java
+++ b/src/main/java/tech/toparvion/jmint/modify/InsteadBodyModifier.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.modify;
+package tech.toparvion.jmint.modify;
 
 import javassist.CannotCompileException;
 import javassist.CtBehavior;
diff --git a/src/main/java/ru/ftc/upc/testing/dropper/modify/MethodModifier.java b/src/main/java/tech/toparvion/jmint/modify/MethodModifier.java
similarity index 84%
rename from src/main/java/ru/ftc/upc/testing/dropper/modify/MethodModifier.java
rename to src/main/java/tech/toparvion/jmint/modify/MethodModifier.java
index 9f607c3..201f8ff 100644
--- a/src/main/java/ru/ftc/upc/testing/dropper/modify/MethodModifier.java
+++ b/src/main/java/tech/toparvion/jmint/modify/MethodModifier.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.modify;
+package tech.toparvion.jmint.modify;
 
 import javassist.CannotCompileException;
 import javassist.CtBehavior;
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/CutpointAssemblerTest.java b/src/test/java/tech/toparvion/jmint/lang/CutpointAssemblerTest.java
similarity index 94%
rename from src/test/java/ru/ftc/upc/testing/dropper/lang/CutpointAssemblerTest.java
rename to src/test/java/tech/toparvion/jmint/lang/CutpointAssemblerTest.java
index d97fe3e..dad22b2 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/CutpointAssemblerTest.java
+++ b/src/test/java/tech/toparvion/jmint/lang/CutpointAssemblerTest.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang;
+package tech.toparvion.jmint.lang;
 
 import org.antlr.v4.runtime.ANTLRFileStream;
 import org.antlr.v4.runtime.CommonTokenStream;
@@ -8,9 +8,9 @@
 import org.junit.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import ru.ftc.upc.testing.dropper.Cutpoint;
-import ru.ftc.upc.testing.dropper.lang.gen.JavadocLexer;
-import ru.ftc.upc.testing.dropper.lang.gen.JavadocParser;
+import tech.toparvion.jmint.Cutpoint;
+import tech.toparvion.jmint.lang.gen.JavadocLexer;
+import tech.toparvion.jmint.lang.gen.JavadocParser;
 
 import java.io.IOException;
 
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java b/src/test/java/tech/toparvion/jmint/lang/DropletAssemblerTest.java
similarity index 82%
rename from src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
rename to src/test/java/tech/toparvion/jmint/lang/DropletAssemblerTest.java
index 3313ad5..04ed235 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/DropletAssemblerTest.java
+++ b/src/test/java/tech/toparvion/jmint/lang/DropletAssemblerTest.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang;
+package tech.toparvion.jmint.lang;
 
 import org.antlr.v4.runtime.ANTLRFileStream;
 import org.antlr.v4.runtime.BufferedTokenStream;
@@ -8,10 +8,10 @@
 import org.junit.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import ru.ftc.upc.testing.dropper.Cutpoint;
-import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaLexer;
-import ru.ftc.upc.testing.dropper.lang.gen.DroppingJavaParser;
-import ru.ftc.upc.testing.dropper.model.TargetsMap;
+import tech.toparvion.jmint.Cutpoint;
+import tech.toparvion.jmint.lang.gen.DroppingJavaLexer;
+import tech.toparvion.jmint.lang.gen.DroppingJavaParser;
+import tech.toparvion.jmint.model.TargetsMap;
 
 import java.io.IOException;
 import java.util.Map;
@@ -27,11 +27,11 @@ public class DropletAssemblerTest {
 
   @Test
   public void nestedClassesAreRecognizedFully() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses.java";
+    String dropletPath = "src/test/java/tech/toparvion/jmint/lang/samples/MultiNestedClasses.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     log.debug(actual);
-    String expected = "ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses -> {\n" +
+    String expected = "tech/toparvion/jmint/lang/samples/MultiNestedClasses -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\t{ return 1 ; }\n" +
             "\t}\n" +
@@ -42,7 +42,7 @@ public void nestedClassesAreRecognizedFully() throws Exception {
             "\t\t{ return 7 ; }\n" +
             "\t}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses$InnerClass1 -> {\n" +
+            "tech/toparvion/jmint/lang/samples/MultiNestedClasses$InnerClass1 -> {\n" +
             "\tTargetMethod{name='method2', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\t{ return 2 ; }\n" +
             "\t}\n" +
@@ -50,12 +50,12 @@ public void nestedClassesAreRecognizedFully() throws Exception {
             "\t\t{ return 3 ; }\n" +
             "\t}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses$InnerClass2 -> {\n" +
+            "tech/toparvion/jmint/lang/samples/MultiNestedClasses$InnerClass2 -> {\n" +
             "\tTargetMethod{name='method5', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\t{ return 5 ; }\n" +
             "\t}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses$InnerClass2$InnerClass3 -> {\n" +
+            "tech/toparvion/jmint/lang/samples/MultiNestedClasses$InnerClass2$InnerClass3 -> {\n" +
             "\tTargetMethod{name='method6', cutpoint=INSTEAD, resultType=int, formalParams=(), text=\n" +
             "\t\t{ return 6 ; }\n" +
             "\t}\n" +
@@ -65,11 +65,11 @@ public void nestedClassesAreRecognizedFully() throws Exception {
 
   @Test
   public void methodHeadersAreRecognizedFully() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java";
+    String dropletPath = "src/test/java/tech/toparvion/jmint/lang/samples/VariousMethodHeaders.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     log.debug(actual);
-    String expected = "ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders -> {\n" +
+    String expected = "tech/toparvion/jmint/lang/samples/VariousMethodHeaders -> {\n" +
             "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(),\n" +
             "\t\timportsOnDemand=(java.util), text=(empty)}\n" +
             "\tTargetMethod{name='VariousMethodHeaders', cutpoint=INSTEAD, resultType=null, formalParams=(Stack param1),\n" +
@@ -103,7 +103,7 @@ public void methodHeadersAreRecognizedFully() throws Exception {
             "\tTargetMethod{name='method10', cutpoint=INSTEAD, resultType=void, formalParams=(java.security.KeyStore$SecretKeyEntry entry),\n" +
             "\t\timportsOnDemand=(java.util), text=(empty)}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders$InnerClass -> {\n" +
+            "tech/toparvion/jmint/lang/samples/VariousMethodHeaders$InnerClass -> {\n" +
             "\tTargetMethod{name='InnerClass', cutpoint=INSTEAD, resultType=null, formalParams=(Deque arg),\n" +
             "\t\timportsOnDemand=(java.util), text=(empty)}\n" +
             "}\n";
@@ -112,11 +112,11 @@ public void methodHeadersAreRecognizedFully() throws Exception {
 
   @Test
   public void methodBodiesAreRecognizedFully() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MethodBodies.java";
+    String dropletPath = "src/test/java/tech/toparvion/jmint/lang/samples/MethodBodies.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     log.debug(actual);
-    String expected = "ru/ftc/upc/testing/dropper/lang/samples/MethodBodies -> {\n" +
+    String expected = "tech/toparvion/jmint/lang/samples/MethodBodies -> {\n" +
             "\tTargetMethod{name='MethodBodies', cutpoint=INSTEAD, resultType=null, formalParams=(String name), text=\n" +
             "\t\t{ System . out . println ( \"Hello from constructor :) \" ) ; }\n" +
             "\t}\n" +
@@ -130,11 +130,11 @@ public void methodBodiesAreRecognizedFully() throws Exception {
 
   @Test
   public void enumTypesAreRecognizedFully() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/RootEnumeration.java";
+    String dropletPath = "src/test/java/tech/toparvion/jmint/lang/samples/RootEnumeration.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     log.debug(actual);
-    String expected = "ru/ftc/upc/testing/dropper/lang/samples/RootEnumeration -> {\n" +
+    String expected = "tech/toparvion/jmint/lang/samples/RootEnumeration -> {\n" +
             "\tTargetMethod{name='RootEnumeration', cutpoint=INSTEAD, resultType=null, formalParams=(), text=\n" +
             "\t\t{ String nothing = \"I'm the most enumerated constructor ever!\" ; }\n" +
             "\t}\n" +
@@ -142,7 +142,7 @@ public void enumTypesAreRecognizedFully() throws Exception {
             "\t\t{ for ( RootEnumeration rootEnum : values ( ) ) { if ( rootEnum . toString ( ) . equals ( $1 ) ) { return rootEnum ; } } throw new IllegalArgumentException ( \"Not found: \" + $1 ) ; }\n" +
             "\t}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/samples/RootEnumeration$InnerEnum -> {\n" +
+            "tech/toparvion/jmint/lang/samples/RootEnumeration$InnerEnum -> {\n" +
             "\tTargetMethod{name='isTheSame', cutpoint=INSTEAD, resultType=boolean, formalParams=(Enum e), text=\n" +
             "\t\t{ return INNER_ENUM . toString ( ) . equals ( $1 . toString ( ) ) ; }\n" +
             "\t}\n" +
@@ -156,7 +156,7 @@ public void interfaceTypesAreRecognizedFully() throws Exception {
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     log.debug(actual);
-    String expected = "ru/ftc/upc/testing/dropper/lang/RootInterface -> {\n" +
+    String expected = "tech/toparvion/jmint/lang/RootInterface -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "\tTargetMethod{name='method2', cutpoint=INSTEAD, resultType=boolean, formalParams=(int two), text=(empty)}\n" +
             "\tTargetMethod{name='method3', cutpoint=INSTEAD, resultType=RootInterface, formalParams=(java.util.Set longs), text=(empty)}\n" +
@@ -167,12 +167,12 @@ public void interfaceTypesAreRecognizedFully() throws Exception {
             "\t\t{ return new java.util.Observable ( ) ; }\n" +
             "\t}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/RootInterface$InnerIface -> {\n" +
+            "tech/toparvion/jmint/lang/RootInterface$InnerIface -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=java.io.InputStream, formalParams=(), text=\n" +
             "\t\t{ return new java.io.FileInputStream ( \"\" ) ; }\n" +
             "\t}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/RootInterface$InnerIface$InnerInnerIface -> {\n" +
+            "tech/toparvion/jmint/lang/RootInterface$InnerIface$InnerInnerIface -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=java.io.OutputStream, formalParams=(), text=\n" +
             "\t\t{ return new java.io.FileOutputStream ( \"\" ) ; }\n" +
             "\t}\n" +
@@ -182,42 +182,42 @@ public void interfaceTypesAreRecognizedFully() throws Exception {
 
   @Test
   public void typesCombinationsAreRecognizedFully() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/TypesCombination.java";
+    String dropletPath = "src/test/java/tech/toparvion/jmint/lang/samples/TypesCombination.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     log.debug(actual);
-    String expected = "ru/ftc/upc/testing/dropper/lang/samples/TypesCombination -> {\n" +
+    String expected = "tech/toparvion/jmint/lang/samples/TypesCombination -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=\n" +
             "\t\t{ System . console ( ) ; }\n" +
             "\t}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/samples/TypesCombination$InnerInterface -> {\n" +
+            "tech/toparvion/jmint/lang/samples/TypesCombination$InnerInterface -> {\n" +
             "\tTargetMethod{name='innerMethod', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/samples/TypesCombination$InnerInterface$InnerInnerClass -> {\n" +
+            "tech/toparvion/jmint/lang/samples/TypesCombination$InnerInterface$InnerInnerClass -> {\n" +
             "\tTargetMethod{name='innerInnerMethod', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/samples/TypesCombination$InnerInterface$InnerInnerClass$InnerInnerInnerEnum -> {\n" +
+            "tech/toparvion/jmint/lang/samples/TypesCombination$InnerInterface$InnerInnerClass$InnerInnerInnerEnum -> {\n" +
             "\tTargetMethod{name='doSomething', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/samples/SiblingClass -> {\n" +
+            "tech/toparvion/jmint/lang/samples/SiblingClass -> {\n" +
             "\tTargetMethod{name='method', cutpoint=INSTEAD, resultType=double, formalParams=(), text=\n" +
             "\t\t{ return Math . random ( ) ; }\n" +
             "\t}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/samples/SiblingEnum -> {\n" +
+            "tech/toparvion/jmint/lang/samples/SiblingEnum -> {\n" +
             "\tTargetMethod{name='SiblingEnum', cutpoint=INSTEAD, resultType=null, formalParams=(), text=(empty)}\n" +
             "\tTargetMethod{name='getMe', cutpoint=INSTEAD, resultType=SiblingEnum, formalParams=(), text=\n" +
             "\t\t{ return this ; }\n" +
             "\t}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/samples/SiblingEnum$InnerInterface -> {\n" +
+            "tech/toparvion/jmint/lang/samples/SiblingEnum$InnerInterface -> {\n" +
             "\tTargetMethod{name='getThatEnum', cutpoint=INSTEAD, resultType=TypesCombination$InnerInterface$InnerInnerClass$InnerInnerInnerEnum, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/samples/SiblingInterface -> {\n" +
+            "tech/toparvion/jmint/lang/samples/SiblingInterface -> {\n" +
             "\tTargetMethod{name='method', cutpoint=INSTEAD, resultType=java.util.Vector, formalParams=(java.util.Vector arg), text=(empty)}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/samples/SiblingInterface$InnerEnum -> {\n" +
+            "tech/toparvion/jmint/lang/samples/SiblingInterface$InnerEnum -> {\n" +
             "\tTargetMethod{name='InnerEnum', cutpoint=INSTEAD, resultType=null, formalParams=(), text=(empty)}\n" +
             "}\n";
     assertEquals(expected, actual);
@@ -239,7 +239,7 @@ public void importMapIsComposedCorrectly() throws Exception {
     TargetsMap targetsMap = dropletAssembler.getTargetsMap();
     String actualTargetsMap = targetsMap.toString();
     log.debug(actualTargetsMap);
-    String expectedTargetsMap = "ru/ftc/upc/testing/dropper/lang/samples/Imports -> {\n" +
+    String expectedTargetsMap = "tech/toparvion/jmint/lang/samples/Imports -> {\n" +
             "\tTargetMethod{name='Imports', cutpoint=INSTEAD, resultType=null, formalParams=(),\n" +
             "\t\timportsOnDemand=(java.math), text=\n" +
             "\t\t{ System . out . println ( ) ; BigInteger bigInteger = new BigInteger ( \"31415926525\" ) ; double java.lang.Math.random = java.lang.Math.random ( ) ; int maxInt = java.lang.Integer.MAX_VALUE ; System . out . printf ( \"%d, %d, %d\" , MAX_EXPONENT , MIN_EXPONENT , MIN_VALUE ) ; }\n" +
@@ -250,7 +250,7 @@ public void importMapIsComposedCorrectly() throws Exception {
 
   @Test
   public void afterCutpointIsRecognizedFully() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/AfterCutpoint.java";
+    String dropletPath = "src/test/java/tech/toparvion/jmint/lang/samples/AfterCutpoint.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     Cutpoint actual = targetsMap.entrySet().iterator().next().getValue().getFirst().getCutpoint();
     log.debug("Actual cutpoint: {}", actual);
@@ -259,7 +259,7 @@ public void afterCutpointIsRecognizedFully() throws Exception {
 
   @Test
   public void defaultCutpointIsAppliedCorrectly() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DefaultCutpoint.java";
+    String dropletPath = "src/test/java/tech/toparvion/jmint/lang/samples/DefaultCutpoint.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     Cutpoint actual = targetsMap.entrySet().iterator().next().getValue().getFirst().getCutpoint();
     log.debug("Actual cutpoint (default): {}", actual);
@@ -282,12 +282,12 @@ public void typeNamesInMethodBodiesAreResolvedCorrectly() throws Exception {
 
   @Test
   public void methodArgumentTypesAreResolvedCorrectly() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/NestedTypesAmongMethodArguments.java";
+    String dropletPath = "src/test/java/tech/toparvion/jmint/lang/samples/NestedTypesAmongMethodArguments.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     log.debug(actual);
 
-    String expected = "ru/ftc/upc/testing/dropper/lang/samples/NestedTypesAmongMethodArguments -> {\n" +
+    String expected = "tech/toparvion/jmint/lang/samples/NestedTypesAmongMethodArguments -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=java.util.Map$Entry, formalParams=(java.security.KeyStore$SecretKeyEntry arg), text=\n" +
             "\t\t{ return new java.util.AbstractMap . SimpleEntry < Long , String > ( 23L , \"\" ) ; }\n" +
             "\t}\n" +
@@ -311,24 +311,24 @@ public void formalParamReferencesAreObfuscatedCorrectly() throws Exception {
 
   @Test
   public void dropletSuffixIsOmittedCorrectly() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffixDroplet.java";
+    String dropletPath = "src/test/java/tech/toparvion/jmint/lang/samples/ClassWithSuffixDroplet.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     log.debug(actual);
 
-    String expected = "ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffix -> {\n" +
+    String expected = "tech/toparvion/jmint/lang/samples/ClassWithSuffix -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffix$InnerClass -> {\n" +
+            "tech/toparvion/jmint/lang/samples/ClassWithSuffix$InnerClass -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffix$InnerClass2 -> {\n" +
+            "tech/toparvion/jmint/lang/samples/ClassWithSuffix$InnerClass2 -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffix$InnerClassDropletNotLatest -> {\n" +
+            "tech/toparvion/jmint/lang/samples/ClassWithSuffix$InnerClassDropletNotLatest -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n" +
-            "ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffix$InnerClassDroplet -> {\n" +
+            "tech/toparvion/jmint/lang/samples/ClassWithSuffix$InnerClassDroplet -> {\n" +
             "\tTargetMethod{name='method1', cutpoint=INSTEAD, resultType=void, formalParams=(), text=(empty)}\n" +
             "}\n";
     assertEquals(expected, actual);
@@ -336,7 +336,7 @@ public void dropletSuffixIsOmittedCorrectly() throws Exception {
 
   @Test(expected = IllegalArgumentException.class)
   public void methodDuplicatesAreDetectedCorrectly() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DuplicatedMethodsDetection.java";
+    String dropletPath = "src/test/java/tech/toparvion/jmint/lang/samples/DuplicatedMethodsDetection.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     log.debug(actual);
@@ -344,7 +344,7 @@ public void methodDuplicatesAreDetectedCorrectly() throws Exception {
 
   @Test(expected = DropletFormatException.class)
   public void parametrizedMethodsAreNotSupported() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass.java";
+    String dropletPath = "src/test/java/tech/toparvion/jmint/lang/samples/GenericClass.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     log.debug(actual);
@@ -355,7 +355,7 @@ public void parametrizedMethodsAreNotSupported() throws Exception {
    */
   @Test(/*expected = DropletFormatException.class*/)
   public void parametrizedParametersInMethodsAreNotSupported() throws Exception {
-    String dropletPath = "src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass2.java";
+    String dropletPath = "src/test/java/tech/toparvion/jmint/lang/samples/GenericClass2.java";
     TargetsMap targetsMap = loadDroplet(dropletPath).getTargetsMap();
     String actual = targetsMap.toString();
     log.debug(actual);
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/DropletLoaderTest.java b/src/test/java/tech/toparvion/jmint/lang/DropletLoaderTest.java
similarity index 66%
rename from src/test/java/ru/ftc/upc/testing/dropper/DropletLoaderTest.java
rename to src/test/java/tech/toparvion/jmint/lang/DropletLoaderTest.java
index 67fdb64..d218a07 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/DropletLoaderTest.java
+++ b/src/test/java/tech/toparvion/jmint/lang/DropletLoaderTest.java
@@ -1,9 +1,10 @@
-package ru.ftc.upc.testing.dropper;
+package tech.toparvion.jmint.lang;
 
+import org.junit.Assert;
 import org.junit.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import ru.ftc.upc.testing.dropper.model.TargetsMap;
+import tech.toparvion.jmint.model.TargetsMap;
 
 /**
  * @author Toparvion
@@ -15,6 +16,9 @@ public class DropletLoaderTest {
   public void loadDroplets() throws Exception {
     String args = "src/test/resources/DPClientImpl.java;src/test/resources/DPClientImpl2.java";
     TargetsMap targetsMap = DropletLoader.loadDroplets(args);
+    Assert.assertTrue((targetsMap != null)
+            && (targetsMap.size() == 1)
+            && (targetsMap.values().iterator().next().size() == 2));
     log.info("Targets map:\n{}", targetsMap.toString());
   }
 
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/AfterCutpoint.java b/src/test/java/tech/toparvion/jmint/lang/samples/AfterCutpoint.java
similarity index 89%
rename from src/test/java/ru/ftc/upc/testing/dropper/lang/samples/AfterCutpoint.java
rename to src/test/java/tech/toparvion/jmint/lang/samples/AfterCutpoint.java
index 9ad18d5..3cc59a5 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/AfterCutpoint.java
+++ b/src/test/java/tech/toparvion/jmint/lang/samples/AfterCutpoint.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang.samples;
+package tech.toparvion.jmint.lang.samples;
 
 import java.util.Collections;
 import java.util.Observable;
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffixDroplet.java b/src/test/java/tech/toparvion/jmint/lang/samples/ClassWithSuffixDroplet.java
similarity index 88%
rename from src/test/java/ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffixDroplet.java
rename to src/test/java/tech/toparvion/jmint/lang/samples/ClassWithSuffixDroplet.java
index e23ce1e..542ac0d 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/ClassWithSuffixDroplet.java
+++ b/src/test/java/tech/toparvion/jmint/lang/samples/ClassWithSuffixDroplet.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang.samples;
+package tech.toparvion.jmint.lang.samples;
 
 /**
  * @author Toparvion
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DefaultCutpoint.java b/src/test/java/tech/toparvion/jmint/lang/samples/DefaultCutpoint.java
similarity index 89%
rename from src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DefaultCutpoint.java
rename to src/test/java/tech/toparvion/jmint/lang/samples/DefaultCutpoint.java
index 6dfc9f9..4e99649 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DefaultCutpoint.java
+++ b/src/test/java/tech/toparvion/jmint/lang/samples/DefaultCutpoint.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang.samples;
+package tech.toparvion.jmint.lang.samples;
 
 import java.util.Collections;
 import java.util.Observable;
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DuplicatedMethodsDetection.java b/src/test/java/tech/toparvion/jmint/lang/samples/DuplicatedMethodsDetection.java
similarity index 90%
rename from src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DuplicatedMethodsDetection.java
rename to src/test/java/tech/toparvion/jmint/lang/samples/DuplicatedMethodsDetection.java
index 73251e8..9247e21 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/DuplicatedMethodsDetection.java
+++ b/src/test/java/tech/toparvion/jmint/lang/samples/DuplicatedMethodsDetection.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang.samples;
+package tech.toparvion.jmint.lang.samples;
 
 /**
  * Target classes may have different names that may be confusing in case several droplets define the same method for
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass.java b/src/test/java/tech/toparvion/jmint/lang/samples/GenericClass.java
similarity index 89%
rename from src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass.java
rename to src/test/java/tech/toparvion/jmint/lang/samples/GenericClass.java
index b9e3fbc..200be77 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass.java
+++ b/src/test/java/tech/toparvion/jmint/lang/samples/GenericClass.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang.samples;
+package tech.toparvion.jmint.lang.samples;
 
 import java.io.InputStream;
 import java.util.AbstractSet;
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass2.java b/src/test/java/tech/toparvion/jmint/lang/samples/GenericClass2.java
similarity index 88%
rename from src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass2.java
rename to src/test/java/tech/toparvion/jmint/lang/samples/GenericClass2.java
index 4f88e36..08282d7 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/GenericClass2.java
+++ b/src/test/java/tech/toparvion/jmint/lang/samples/GenericClass2.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang.samples;
+package tech.toparvion.jmint.lang.samples;
 
 import java.util.AbstractSet;
 import java.util.Iterator;
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MethodBodies.java b/src/test/java/tech/toparvion/jmint/lang/samples/MethodBodies.java
similarity index 88%
rename from src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MethodBodies.java
rename to src/test/java/tech/toparvion/jmint/lang/samples/MethodBodies.java
index ae0f7ba..e79cba0 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MethodBodies.java
+++ b/src/test/java/tech/toparvion/jmint/lang/samples/MethodBodies.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang.samples;
+package tech.toparvion.jmint.lang.samples;
 
 /**
  * @author Toparvion
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses.java b/src/test/java/tech/toparvion/jmint/lang/samples/MultiNestedClasses.java
similarity index 89%
rename from src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses.java
rename to src/test/java/tech/toparvion/jmint/lang/samples/MultiNestedClasses.java
index 8ecaf39..38a1b66 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/MultiNestedClasses.java
+++ b/src/test/java/tech/toparvion/jmint/lang/samples/MultiNestedClasses.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang.samples;
+package tech.toparvion.jmint.lang.samples;
 
 /**
  * @author Toparvion
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/NestedTypesAmongMethodArguments.java b/src/test/java/tech/toparvion/jmint/lang/samples/NestedTypesAmongMethodArguments.java
similarity index 87%
rename from src/test/java/ru/ftc/upc/testing/dropper/lang/samples/NestedTypesAmongMethodArguments.java
rename to src/test/java/tech/toparvion/jmint/lang/samples/NestedTypesAmongMethodArguments.java
index 3bbe2e0..59327a6 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/NestedTypesAmongMethodArguments.java
+++ b/src/test/java/tech/toparvion/jmint/lang/samples/NestedTypesAmongMethodArguments.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang.samples;
+package tech.toparvion.jmint.lang.samples;
 
 import java.security.KeyStore;
 import java.util.AbstractMap;
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/RootEnumeration.java b/src/test/java/tech/toparvion/jmint/lang/samples/RootEnumeration.java
similarity index 92%
rename from src/test/java/ru/ftc/upc/testing/dropper/lang/samples/RootEnumeration.java
rename to src/test/java/tech/toparvion/jmint/lang/samples/RootEnumeration.java
index a49fe93..f1f455c 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/RootEnumeration.java
+++ b/src/test/java/tech/toparvion/jmint/lang/samples/RootEnumeration.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang.samples;
+package tech.toparvion.jmint.lang.samples;
 
 /**
  * @author Toparvion
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/TypesCombination.java b/src/test/java/tech/toparvion/jmint/lang/samples/TypesCombination.java
similarity index 95%
rename from src/test/java/ru/ftc/upc/testing/dropper/lang/samples/TypesCombination.java
rename to src/test/java/tech/toparvion/jmint/lang/samples/TypesCombination.java
index e586157..d5a2ecf 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/TypesCombination.java
+++ b/src/test/java/tech/toparvion/jmint/lang/samples/TypesCombination.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang.samples;
+package tech.toparvion.jmint.lang.samples;
 
 import java.util.Vector;
 
diff --git a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java b/src/test/java/tech/toparvion/jmint/lang/samples/VariousMethodHeaders.java
similarity index 94%
rename from src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java
rename to src/test/java/tech/toparvion/jmint/lang/samples/VariousMethodHeaders.java
index 360c508..2f234b5 100644
--- a/src/test/java/ru/ftc/upc/testing/dropper/lang/samples/VariousMethodHeaders.java
+++ b/src/test/java/tech/toparvion/jmint/lang/samples/VariousMethodHeaders.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang.samples;
+package tech.toparvion.jmint.lang.samples;
 
 import java.security.KeyStore;
 import java.util.*;
diff --git a/src/test/resources/FaultyTypesCombination.java b/src/test/resources/FaultyTypesCombination.java
index 437a4a5..05fd819 100644
--- a/src/test/resources/FaultyTypesCombination.java
+++ b/src/test/resources/FaultyTypesCombination.java
@@ -1,5 +1,7 @@
 package ru.ftc.upc.testing.dropper.lang.samples;
 
+import tech.toparvion.jmint.lang.samples.TypesCombination;
+
 import java.util.Vector;
 
 /**
diff --git a/src/test/resources/Imports.java b/src/test/resources/Imports.java
index 0d3ee00..f064f97 100644
--- a/src/test/resources/Imports.java
+++ b/src/test/resources/Imports.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang.samples;
+package tech.toparvion.jmint.lang.samples;
 
 import java.util.Currency;
 import Object;                  // must be ignored by assembler
diff --git a/src/test/resources/RootInterface.java b/src/test/resources/RootInterface.java
index 1aecccc..48812a6 100644
--- a/src/test/resources/RootInterface.java
+++ b/src/test/resources/RootInterface.java
@@ -1,4 +1,4 @@
-package ru.ftc.upc.testing.dropper.lang;
+package tech.toparvion.jmint.lang;
 
 import java.io.FileInputStream;
 import java.io.FileOutputStream;

From d25c3a76d4aead2584d16fa34e1cbd1f5020da6e Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Fri, 8 Jul 2016 00:51:22 +0600
Subject: [PATCH 20/22] Added temporary stub for catch cutpoint implementation

---
 src/main/java/tech/toparvion/jmint/Cutpoint.java |  7 ++-----
 .../jmint/modify/CatchBodyModifier.java          | 16 ++++++++++++++++
 2 files changed, 18 insertions(+), 5 deletions(-)
 create mode 100644 src/main/java/tech/toparvion/jmint/modify/CatchBodyModifier.java

diff --git a/src/main/java/tech/toparvion/jmint/Cutpoint.java b/src/main/java/tech/toparvion/jmint/Cutpoint.java
index 2101122..60c6270 100644
--- a/src/main/java/tech/toparvion/jmint/Cutpoint.java
+++ b/src/main/java/tech/toparvion/jmint/Cutpoint.java
@@ -1,9 +1,6 @@
 package tech.toparvion.jmint;
 
-import tech.toparvion.jmint.modify.AfterBodyModifier;
-import tech.toparvion.jmint.modify.BeforeBodyModifier;
-import tech.toparvion.jmint.modify.InsteadBodyModifier;
-import tech.toparvion.jmint.modify.MethodModifier;
+import tech.toparvion.jmint.modify.*;
 
 /**
  * Created by Toparvion on 29.04.2016 11:59
@@ -12,7 +9,7 @@ public enum Cutpoint {
   BEFORE(BeforeBodyModifier.class),
   INSTEAD(InsteadBodyModifier.class),
   AFTER(AfterBodyModifier.class),
-  CATCH(MethodModifier.class),                // TODO implement dedicated modifier
+  CATCH(CatchBodyModifier.class),
   /**
    * This synthetic cutpoint is introduced to denote a method that must not be instrumented. This however doesn't
    * mean that the method must not be included into targets map. It is still included there to avoid breaking the
diff --git a/src/main/java/tech/toparvion/jmint/modify/CatchBodyModifier.java b/src/main/java/tech/toparvion/jmint/modify/CatchBodyModifier.java
new file mode 100644
index 0000000..d01d882
--- /dev/null
+++ b/src/main/java/tech/toparvion/jmint/modify/CatchBodyModifier.java
@@ -0,0 +1,16 @@
+package tech.toparvion.jmint.modify;
+
+import javassist.CannotCompileException;
+import javassist.CtBehavior;
+
+/**
+ * @author Toparvion
+ */
+public class CatchBodyModifier implements MethodModifier {
+
+  @Override
+  public void apply(CtBehavior method, String injection) throws CannotCompileException {
+    throw new RuntimeException("CATCH cutpoint is not supported yet. Please post an issue on " +
+            "https://github.com/Toparvion/jmint to require the support in one of upcoming versions.");
+  }
+}

From 18685245ecac4a5d3463df5e970696b135289584 Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Fri, 8 Jul 2016 01:03:42 +0600
Subject: [PATCH 21/22] Added MIT license

---
 LICENSE.txt | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 LICENSE.txt

diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 0000000..79d88d0
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Toparvion
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file

From 5b6860a03bed9f862e159c3a27815894439b93ac Mon Sep 17 00:00:00 2001
From: Toparvion <toparvion@gmx.com>
Date: Fri, 8 Jul 2016 22:58:22 +0600
Subject: [PATCH 22/22] Updated LICENSE.txt with license texts of all included
 third-party libraries

---
 LICENSE.txt | 228 +++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 227 insertions(+), 1 deletion(-)

diff --git a/LICENSE.txt b/LICENSE.txt
index 79d88d0..4389b6b 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1,3 +1,6 @@
+---------------------------------------------------------------------------------------------------------------
+jMint License
+---------------------------------------------------------------------------------------------------------------
 MIT License
 
 Copyright (c) 2016 Toparvion
@@ -18,4 +21,227 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
\ No newline at end of file
+SOFTWARE.
+===============================================================================================================
+
+
+---------------------------------------------------------------------------------------------------------------
+ANTLR4 License
+---------------------------------------------------------------------------------------------------------------
+[The BSD License]
+Copyright (c) 2012 Terence Parr and Sam Harwell
+All rights reserved.
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that
+the following conditions are met:
+- Redistributions of source code must retain the above copyright notice, this list of conditions and the
+following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other materials provided with the distribution.
+- Neither the name of the author nor the names of its contributors may be used to endorse or promote products
+derived from this software without specific prior written permission.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+===============================================================================================================
+
+
+---------------------------------------------------------------------------------------------------------------
+Javassist License
+---------------------------------------------------------------------------------------------------------------
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
+===============================================================================================================
+
+
+---------------------------------------------------------------------------------------------------------------
+SLF4J License
+---------------------------------------------------------------------------------------------------------------
+Copyright (c) 2004-2013 QOS.ch
+ All rights reserved.
+
+ Permission is hereby granted, free  of charge, to any person obtaining
+ a  copy  of this  software  and  associated  documentation files  (the
+ "Software"), to  deal in  the Software without  restriction, including
+ without limitation  the rights to  use, copy, modify,  merge, publish,
+ distribute,  sublicense, and/or sell  copies of  the Software,  and to
+ permit persons to whom the Software  is furnished to do so, subject to
+ the following conditions:
+
+ The  above  copyright  notice  and  this permission  notice  shall  be
+ included in all copies or substantial portions of the Software.
+
+ THE  SOFTWARE IS  PROVIDED  "AS  IS", WITHOUT  WARRANTY  OF ANY  KIND,
+ EXPRESS OR  IMPLIED, INCLUDING  BUT NOT LIMITED  TO THE  WARRANTIES OF
+ MERCHANTABILITY,    FITNESS    FOR    A   PARTICULAR    PURPOSE    AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ OF CONTRACT, TORT OR OTHERWISE,  ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ===============================================================================================================